/**
 *
 */
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @endpointRule = '';
  
  checkConfig(config);
  @endpoint = getEndpoint('datatrust', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }
  
  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}

model CreateMpcPrivateIdJobRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  participantList?: [ 
    {
      participantId?: long(name='ParticipantId'),
      participantName?: string(name='ParticipantName'),
    }
  ](name='ParticipantList'),
  planList?: [ string ](name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
}

model CreateMpcPrivateIdJobShrinkRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  participantList?: [ 
    {
      participantId?: long(name='ParticipantId'),
      participantName?: string(name='ParticipantName'),
    }
  ](name='ParticipantList'),
  planListShrink?: string(name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeListShrink?: string(name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
}

model CreateMpcPrivateIdJobResponseBody = {
  code?: long(name='Code'),
  data?: long(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateMpcPrivateIdJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateMpcPrivateIdJobResponseBody(name='body'),
}

async function createMpcPrivateIdJobWithOptions(tmpReq: CreateMpcPrivateIdJobRequest, runtime: Util.RuntimeOptions): CreateMpcPrivateIdJobResponse {
  Util.validateModel(tmpReq);
  var request = new CreateMpcPrivateIdJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.planList)) {
    request.planListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.planList, 'PlanList', 'json');
  }
  if (!Util.isUnset(tmpReq.protocolTypeList)) {
    request.protocolTypeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.protocolTypeList, 'ProtocolTypeList', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.configuration)) {
    body['Configuration'] = request.configuration;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobStatus)) {
    body['JobStatus'] = request.jobStatus;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modeName)) {
    body['ModeName'] = request.modeName;
  }
  if (!Util.isUnset(request.participantList)) {
    body['ParticipantList'] = request.participantList;
  }
  if (!Util.isUnset(request.planListShrink)) {
    body['PlanList'] = request.planListShrink;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.protocolTypeListShrink)) {
    body['ProtocolTypeList'] = request.protocolTypeListShrink;
  }
  if (!Util.isUnset(request.scheduleCron)) {
    body['ScheduleCron'] = request.scheduleCron;
  }
  if (!Util.isUnset(request.scheduleType)) {
    body['ScheduleType'] = request.scheduleType;
  }
  if (!Util.isUnset(request.scheduleTypeName)) {
    body['ScheduleTypeName'] = request.scheduleTypeName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateMpcPrivateIdJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createMpcPrivateIdJob(request: CreateMpcPrivateIdJobRequest): CreateMpcPrivateIdJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return createMpcPrivateIdJobWithOptions(request, runtime);
}

model CreateMpcSqlJobRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  inputs?: [ string ](name='Inputs'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  outputs?: [ string ](name='Outputs'),
  planList?: [ string ](name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  sql?: string(name='Sql'),
}

model CreateMpcSqlJobShrinkRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  inputsShrink?: string(name='Inputs'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  outputsShrink?: string(name='Outputs'),
  planListShrink?: string(name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeListShrink?: string(name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  sql?: string(name='Sql'),
}

model CreateMpcSqlJobResponseBody = {
  code?: long(name='Code'),
  data?: long(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateMpcSqlJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateMpcSqlJobResponseBody(name='body'),
}

async function createMpcSqlJobWithOptions(tmpReq: CreateMpcSqlJobRequest, runtime: Util.RuntimeOptions): CreateMpcSqlJobResponse {
  Util.validateModel(tmpReq);
  var request = new CreateMpcSqlJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.inputs)) {
    request.inputsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.inputs, 'Inputs', 'json');
  }
  if (!Util.isUnset(tmpReq.outputs)) {
    request.outputsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.outputs, 'Outputs', 'json');
  }
  if (!Util.isUnset(tmpReq.planList)) {
    request.planListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.planList, 'PlanList', 'json');
  }
  if (!Util.isUnset(tmpReq.protocolTypeList)) {
    request.protocolTypeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.protocolTypeList, 'ProtocolTypeList', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.configuration)) {
    body['Configuration'] = request.configuration;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.inputsShrink)) {
    body['Inputs'] = request.inputsShrink;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobStatus)) {
    body['JobStatus'] = request.jobStatus;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modeName)) {
    body['ModeName'] = request.modeName;
  }
  if (!Util.isUnset(request.outputsShrink)) {
    body['Outputs'] = request.outputsShrink;
  }
  if (!Util.isUnset(request.planListShrink)) {
    body['PlanList'] = request.planListShrink;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.protocolTypeListShrink)) {
    body['ProtocolTypeList'] = request.protocolTypeListShrink;
  }
  if (!Util.isUnset(request.scheduleCron)) {
    body['ScheduleCron'] = request.scheduleCron;
  }
  if (!Util.isUnset(request.scheduleType)) {
    body['ScheduleType'] = request.scheduleType;
  }
  if (!Util.isUnset(request.scheduleTypeName)) {
    body['ScheduleTypeName'] = request.scheduleTypeName;
  }
  if (!Util.isUnset(request.sql)) {
    body['Sql'] = request.sql;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateMpcSqlJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createMpcSqlJob(request: CreateMpcSqlJobRequest): CreateMpcSqlJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return createMpcSqlJobWithOptions(request, runtime);
}

model CreatePrivateIdJobRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  participantList?: [ 
    {
      participantId?: long(name='ParticipantId'),
      participantName?: string(name='ParticipantName'),
    }
  ](name='ParticipantList'),
  planList?: [ string ](name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
}

model CreatePrivateIdJobShrinkRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  participantList?: [ 
    {
      participantId?: long(name='ParticipantId'),
      participantName?: string(name='ParticipantName'),
    }
  ](name='ParticipantList'),
  planListShrink?: string(name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeListShrink?: string(name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
}

model CreatePrivateIdJobResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreatePrivateIdJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreatePrivateIdJobResponseBody(name='body'),
}

async function createPrivateIdJobWithOptions(tmpReq: CreatePrivateIdJobRequest, runtime: Util.RuntimeOptions): CreatePrivateIdJobResponse {
  Util.validateModel(tmpReq);
  var request = new CreatePrivateIdJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.planList)) {
    request.planListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.planList, 'PlanList', 'json');
  }
  if (!Util.isUnset(tmpReq.protocolTypeList)) {
    request.protocolTypeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.protocolTypeList, 'ProtocolTypeList', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.configuration)) {
    body['Configuration'] = request.configuration;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobStatus)) {
    body['JobStatus'] = request.jobStatus;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modeName)) {
    body['ModeName'] = request.modeName;
  }
  if (!Util.isUnset(request.participantList)) {
    body['ParticipantList'] = request.participantList;
  }
  if (!Util.isUnset(request.planListShrink)) {
    body['PlanList'] = request.planListShrink;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.protocolTypeListShrink)) {
    body['ProtocolTypeList'] = request.protocolTypeListShrink;
  }
  if (!Util.isUnset(request.scheduleCron)) {
    body['ScheduleCron'] = request.scheduleCron;
  }
  if (!Util.isUnset(request.scheduleType)) {
    body['ScheduleType'] = request.scheduleType;
  }
  if (!Util.isUnset(request.scheduleTypeName)) {
    body['ScheduleTypeName'] = request.scheduleTypeName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreatePrivateIdJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createPrivateIdJob(request: CreatePrivateIdJobRequest): CreatePrivateIdJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return createPrivateIdJobWithOptions(request, runtime);
}

model CreateProjectRequest {
  description?: string(name='Description'),
  memberId?: long(name='MemberId'),
  projectModeList?: [ int32 ](name='ProjectModeList'),
  projectName?: string(name='ProjectName'),
}

model CreateProjectShrinkRequest {
  description?: string(name='Description'),
  memberId?: long(name='MemberId'),
  projectModeListShrink?: string(name='ProjectModeList'),
  projectName?: string(name='ProjectName'),
}

model CreateProjectResponseBody = {
  code?: long(name='Code'),
  data?: long(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateProjectResponseBody(name='body'),
}

async function createProjectWithOptions(tmpReq: CreateProjectRequest, runtime: Util.RuntimeOptions): CreateProjectResponse {
  Util.validateModel(tmpReq);
  var request = new CreateProjectShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.projectModeList)) {
    request.projectModeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.projectModeList, 'ProjectModeList', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.description)) {
    body['Description'] = request.description;
  }
  if (!Util.isUnset(request.memberId)) {
    body['MemberId'] = request.memberId;
  }
  if (!Util.isUnset(request.projectModeListShrink)) {
    body['ProjectModeList'] = request.projectModeListShrink;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateProject',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createProject(request: CreateProjectRequest): CreateProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return createProjectWithOptions(request, runtime);
}

model CreateProjectMetaRequest {
  projectType?: int32(name='ProjectType'),
  sourceTableId?: long(name='SourceTableId'),
  targetProjectId?: long(name='TargetProjectId'),
  targetTableName?: string(name='TargetTableName'),
}

model CreateProjectMetaResponseBody = {
  code?: long(name='Code'),
  data?: long(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateProjectMetaResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateProjectMetaResponseBody(name='body'),
}

async function createProjectMetaWithOptions(request: CreateProjectMetaRequest, runtime: Util.RuntimeOptions): CreateProjectMetaResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.projectType)) {
    body['ProjectType'] = request.projectType;
  }
  if (!Util.isUnset(request.sourceTableId)) {
    body['SourceTableId'] = request.sourceTableId;
  }
  if (!Util.isUnset(request.targetProjectId)) {
    body['TargetProjectId'] = request.targetProjectId;
  }
  if (!Util.isUnset(request.targetTableName)) {
    body['TargetTableName'] = request.targetTableName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateProjectMeta',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createProjectMeta(request: CreateProjectMetaRequest): CreateProjectMetaResponse {
  var runtime = new Util.RuntimeOptions{};
  return createProjectMetaWithOptions(request, runtime);
}

model CreateTrustDaPsiJobRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  planList?: [ string ](name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  psiPreCacheConfig?: {
    cacheUsage?: long(name='CacheUsage'),
    isUsePsiPreCache?: boolean(name='IsUsePsiPreCache'),
    localBasePath?: string(name='LocalBasePath'),
    psiPreCacheColumn?: [ string ](name='PsiPreCacheColumn'),
    psiPreCacheDataName?: string(name='PsiPreCacheDataName'),
    psiPreCacheJobId?: long(name='PsiPreCacheJobId'),
    psiPreCacheJobName?: string(name='PsiPreCacheJobName'),
  }(name='PsiPreCacheConfig'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  sql?: string(name='Sql'),
}

model CreateTrustDaPsiJobShrinkRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  planListShrink?: string(name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeListShrink?: string(name='ProtocolTypeList'),
  psiPreCacheConfigShrink?: string(name='PsiPreCacheConfig'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  sql?: string(name='Sql'),
}

model CreateTrustDaPsiJobResponseBody = {
  code?: long(name='Code'),
  data?: long(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateTrustDaPsiJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateTrustDaPsiJobResponseBody(name='body'),
}

async function createTrustDaPsiJobWithOptions(tmpReq: CreateTrustDaPsiJobRequest, runtime: Util.RuntimeOptions): CreateTrustDaPsiJobResponse {
  Util.validateModel(tmpReq);
  var request = new CreateTrustDaPsiJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.planList)) {
    request.planListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.planList, 'PlanList', 'json');
  }
  if (!Util.isUnset(tmpReq.protocolTypeList)) {
    request.protocolTypeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.protocolTypeList, 'ProtocolTypeList', 'json');
  }
  if (!Util.isUnset(tmpReq.psiPreCacheConfig)) {
    request.psiPreCacheConfigShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.psiPreCacheConfig, 'PsiPreCacheConfig', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.configuration)) {
    body['Configuration'] = request.configuration;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobStatus)) {
    body['JobStatus'] = request.jobStatus;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modeName)) {
    body['ModeName'] = request.modeName;
  }
  if (!Util.isUnset(request.planListShrink)) {
    body['PlanList'] = request.planListShrink;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.protocolTypeListShrink)) {
    body['ProtocolTypeList'] = request.protocolTypeListShrink;
  }
  if (!Util.isUnset(request.psiPreCacheConfigShrink)) {
    body['PsiPreCacheConfig'] = request.psiPreCacheConfigShrink;
  }
  if (!Util.isUnset(request.scheduleCron)) {
    body['ScheduleCron'] = request.scheduleCron;
  }
  if (!Util.isUnset(request.scheduleType)) {
    body['ScheduleType'] = request.scheduleType;
  }
  if (!Util.isUnset(request.scheduleTypeName)) {
    body['ScheduleTypeName'] = request.scheduleTypeName;
  }
  if (!Util.isUnset(request.sql)) {
    body['Sql'] = request.sql;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateTrustDaPsiJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createTrustDaPsiJob(request: CreateTrustDaPsiJobRequest): CreateTrustDaPsiJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return createTrustDaPsiJobWithOptions(request, runtime);
}

model CreateTrustDaPsiPreCacheJobRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  planList?: [ string ](name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  psiPreCacheConfig?: {
    cacheUsage?: long(name='CacheUsage'),
    isUsePsiPreCache?: boolean(name='IsUsePsiPreCache'),
    localBasePath?: string(name='LocalBasePath'),
    psiPreCacheColumn?: [ string ](name='PsiPreCacheColumn'),
    psiPreCacheDataName?: string(name='PsiPreCacheDataName'),
    psiPreCacheJobId?: long(name='PsiPreCacheJobId'),
    psiPreCacheJobName?: string(name='PsiPreCacheJobName'),
  }(name='PsiPreCacheConfig'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
}

model CreateTrustDaPsiPreCacheJobShrinkRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  planListShrink?: string(name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeListShrink?: string(name='ProtocolTypeList'),
  psiPreCacheConfigShrink?: string(name='PsiPreCacheConfig'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
}

model CreateTrustDaPsiPreCacheJobResponseBody = {
  code?: long(name='Code'),
  data?: long(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateTrustDaPsiPreCacheJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateTrustDaPsiPreCacheJobResponseBody(name='body'),
}

async function createTrustDaPsiPreCacheJobWithOptions(tmpReq: CreateTrustDaPsiPreCacheJobRequest, runtime: Util.RuntimeOptions): CreateTrustDaPsiPreCacheJobResponse {
  Util.validateModel(tmpReq);
  var request = new CreateTrustDaPsiPreCacheJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.planList)) {
    request.planListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.planList, 'PlanList', 'json');
  }
  if (!Util.isUnset(tmpReq.protocolTypeList)) {
    request.protocolTypeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.protocolTypeList, 'ProtocolTypeList', 'json');
  }
  if (!Util.isUnset(tmpReq.psiPreCacheConfig)) {
    request.psiPreCacheConfigShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.psiPreCacheConfig, 'PsiPreCacheConfig', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.configuration)) {
    body['Configuration'] = request.configuration;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobStatus)) {
    body['JobStatus'] = request.jobStatus;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modeName)) {
    body['ModeName'] = request.modeName;
  }
  if (!Util.isUnset(request.planListShrink)) {
    body['PlanList'] = request.planListShrink;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.protocolTypeListShrink)) {
    body['ProtocolTypeList'] = request.protocolTypeListShrink;
  }
  if (!Util.isUnset(request.psiPreCacheConfigShrink)) {
    body['PsiPreCacheConfig'] = request.psiPreCacheConfigShrink;
  }
  if (!Util.isUnset(request.scheduleCron)) {
    body['ScheduleCron'] = request.scheduleCron;
  }
  if (!Util.isUnset(request.scheduleType)) {
    body['ScheduleType'] = request.scheduleType;
  }
  if (!Util.isUnset(request.scheduleTypeName)) {
    body['ScheduleTypeName'] = request.scheduleTypeName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateTrustDaPsiPreCacheJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createTrustDaPsiPreCacheJob(request: CreateTrustDaPsiPreCacheJobRequest): CreateTrustDaPsiPreCacheJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return createTrustDaPsiPreCacheJobWithOptions(request, runtime);
}

model CreateTrustDaSqlJobRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  inputs?: [ string ](name='Inputs'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  outputs?: [ string ](name='Outputs'),
  planList?: [ string ](name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  sql?: string(name='Sql'),
}

model CreateTrustDaSqlJobShrinkRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  inputsShrink?: string(name='Inputs'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  outputsShrink?: string(name='Outputs'),
  planListShrink?: string(name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeListShrink?: string(name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  sql?: string(name='Sql'),
}

model CreateTrustDaSqlJobResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateTrustDaSqlJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateTrustDaSqlJobResponseBody(name='body'),
}

async function createTrustDaSqlJobWithOptions(tmpReq: CreateTrustDaSqlJobRequest, runtime: Util.RuntimeOptions): CreateTrustDaSqlJobResponse {
  Util.validateModel(tmpReq);
  var request = new CreateTrustDaSqlJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.inputs)) {
    request.inputsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.inputs, 'Inputs', 'json');
  }
  if (!Util.isUnset(tmpReq.outputs)) {
    request.outputsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.outputs, 'Outputs', 'json');
  }
  if (!Util.isUnset(tmpReq.planList)) {
    request.planListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.planList, 'PlanList', 'json');
  }
  if (!Util.isUnset(tmpReq.protocolTypeList)) {
    request.protocolTypeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.protocolTypeList, 'ProtocolTypeList', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.configuration)) {
    body['Configuration'] = request.configuration;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.inputsShrink)) {
    body['Inputs'] = request.inputsShrink;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobStatus)) {
    body['JobStatus'] = request.jobStatus;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modeName)) {
    body['ModeName'] = request.modeName;
  }
  if (!Util.isUnset(request.outputsShrink)) {
    body['Outputs'] = request.outputsShrink;
  }
  if (!Util.isUnset(request.planListShrink)) {
    body['PlanList'] = request.planListShrink;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.protocolTypeListShrink)) {
    body['ProtocolTypeList'] = request.protocolTypeListShrink;
  }
  if (!Util.isUnset(request.scheduleCron)) {
    body['ScheduleCron'] = request.scheduleCron;
  }
  if (!Util.isUnset(request.scheduleType)) {
    body['ScheduleType'] = request.scheduleType;
  }
  if (!Util.isUnset(request.scheduleTypeName)) {
    body['ScheduleTypeName'] = request.scheduleTypeName;
  }
  if (!Util.isUnset(request.sql)) {
    body['Sql'] = request.sql;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateTrustDaSqlJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createTrustDaSqlJob(request: CreateTrustDaSqlJobRequest): CreateTrustDaSqlJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return createTrustDaSqlJobWithOptions(request, runtime);
}

model CreateTrustMlDataProcessConfigRequest {
  dataProcessDtoList?: [ 
    {
      binningCount?: int32(name='BinningCount'),
      binningInterval?: string(name='BinningInterval'),
      binningType?: int32(name='BinningType'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      field?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='Field'),
      processType?: int32(name='ProcessType'),
      processedValue?: string(name='ProcessedValue'),
      rawValues?: [ string ](name='RawValues'),
    }
  ](name='DataProcessDtoList'),
  jobId?: long(name='JobId'),
  jobMode?: int32(name='JobMode'),
  jobType?: int32(name='JobType'),
}

model CreateTrustMlDataProcessConfigResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateTrustMlDataProcessConfigResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateTrustMlDataProcessConfigResponseBody(name='body'),
}

async function createTrustMlDataProcessConfigWithOptions(request: CreateTrustMlDataProcessConfigRequest, runtime: Util.RuntimeOptions): CreateTrustMlDataProcessConfigResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.dataProcessDtoList)) {
    body['DataProcessDtoList'] = request.dataProcessDtoList;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobMode)) {
    body['JobMode'] = request.jobMode;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateTrustMlDataProcessConfig',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createTrustMlDataProcessConfig(request: CreateTrustMlDataProcessConfigRequest): CreateTrustMlDataProcessConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return createTrustMlDataProcessConfigWithOptions(request, runtime);
}

model CreateTrustMlPredictionJobRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataProcessDtoList?: [ 
    {
      binningCount?: int32(name='BinningCount'),
      binningInterval?: string(name='BinningInterval'),
      binningType?: int32(name='BinningType'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      field?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='Field'),
      processType?: int32(name='ProcessType'),
      processedValue?: string(name='ProcessedValue'),
      rawValues?: [ string ](name='RawValues'),
    }
  ](name='DataProcessDtoList'),
  dataProcessTypeOrder?: [ int32 ](name='DataProcessTypeOrder'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  featureDistribution?: int32(name='FeatureDistribution'),
  featureFormat?: int32(name='FeatureFormat'),
  gmtCreate?: string(name='GmtCreate'),
  hostFeatureNum?: int32(name='HostFeatureNum'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  outputDs?: string(name='OutputDs'),
  outputId?: long(name='OutputId'),
  outputName?: string(name='OutputName'),
  partitionType?: int32(name='PartitionType'),
  planList?: [ string ](name='PlanList'),
  predictionResultTo?: int32(name='PredictionResultTo'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  serviceApiId?: string(name='ServiceApiId'),
  slaveFeatureNum?: int32(name='SlaveFeatureNum'),
  trainingJobId?: long(name='TrainingJobId'),
  trainingJobName?: string(name='TrainingJobName'),
  trainingModelId?: long(name='TrainingModelId'),
  trainingModelName?: string(name='TrainingModelName'),
  trainingModelVersion?: string(name='TrainingModelVersion'),
  trainingModelVersionName?: string(name='TrainingModelVersionName'),
}

model CreateTrustMlPredictionJobShrinkRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataProcessDtoList?: [ 
    {
      binningCount?: int32(name='BinningCount'),
      binningInterval?: string(name='BinningInterval'),
      binningType?: int32(name='BinningType'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      field?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='Field'),
      processType?: int32(name='ProcessType'),
      processedValue?: string(name='ProcessedValue'),
      rawValues?: [ string ](name='RawValues'),
    }
  ](name='DataProcessDtoList'),
  dataProcessTypeOrderShrink?: string(name='DataProcessTypeOrder'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  featureDistribution?: int32(name='FeatureDistribution'),
  featureFormat?: int32(name='FeatureFormat'),
  gmtCreate?: string(name='GmtCreate'),
  hostFeatureNum?: int32(name='HostFeatureNum'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  outputDs?: string(name='OutputDs'),
  outputId?: long(name='OutputId'),
  outputName?: string(name='OutputName'),
  partitionType?: int32(name='PartitionType'),
  planListShrink?: string(name='PlanList'),
  predictionResultTo?: int32(name='PredictionResultTo'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeListShrink?: string(name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  serviceApiId?: string(name='ServiceApiId'),
  slaveFeatureNum?: int32(name='SlaveFeatureNum'),
  trainingJobId?: long(name='TrainingJobId'),
  trainingJobName?: string(name='TrainingJobName'),
  trainingModelId?: long(name='TrainingModelId'),
  trainingModelName?: string(name='TrainingModelName'),
  trainingModelVersion?: string(name='TrainingModelVersion'),
  trainingModelVersionName?: string(name='TrainingModelVersionName'),
}

model CreateTrustMlPredictionJobResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateTrustMlPredictionJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateTrustMlPredictionJobResponseBody(name='body'),
}

async function createTrustMlPredictionJobWithOptions(tmpReq: CreateTrustMlPredictionJobRequest, runtime: Util.RuntimeOptions): CreateTrustMlPredictionJobResponse {
  Util.validateModel(tmpReq);
  var request = new CreateTrustMlPredictionJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.dataProcessTypeOrder)) {
    request.dataProcessTypeOrderShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.dataProcessTypeOrder, 'DataProcessTypeOrder', 'json');
  }
  if (!Util.isUnset(tmpReq.planList)) {
    request.planListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.planList, 'PlanList', 'json');
  }
  if (!Util.isUnset(tmpReq.protocolTypeList)) {
    request.protocolTypeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.protocolTypeList, 'ProtocolTypeList', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.configuration)) {
    body['Configuration'] = request.configuration;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.dataProcessDtoList)) {
    body['DataProcessDtoList'] = request.dataProcessDtoList;
  }
  if (!Util.isUnset(request.dataProcessTypeOrderShrink)) {
    body['DataProcessTypeOrder'] = request.dataProcessTypeOrderShrink;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.featureDistribution)) {
    body['FeatureDistribution'] = request.featureDistribution;
  }
  if (!Util.isUnset(request.featureFormat)) {
    body['FeatureFormat'] = request.featureFormat;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.hostFeatureNum)) {
    body['HostFeatureNum'] = request.hostFeatureNum;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobStatus)) {
    body['JobStatus'] = request.jobStatus;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modeName)) {
    body['ModeName'] = request.modeName;
  }
  if (!Util.isUnset(request.outputDs)) {
    body['OutputDs'] = request.outputDs;
  }
  if (!Util.isUnset(request.outputId)) {
    body['OutputId'] = request.outputId;
  }
  if (!Util.isUnset(request.outputName)) {
    body['OutputName'] = request.outputName;
  }
  if (!Util.isUnset(request.partitionType)) {
    body['PartitionType'] = request.partitionType;
  }
  if (!Util.isUnset(request.planListShrink)) {
    body['PlanList'] = request.planListShrink;
  }
  if (!Util.isUnset(request.predictionResultTo)) {
    body['PredictionResultTo'] = request.predictionResultTo;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.protocolTypeListShrink)) {
    body['ProtocolTypeList'] = request.protocolTypeListShrink;
  }
  if (!Util.isUnset(request.scheduleCron)) {
    body['ScheduleCron'] = request.scheduleCron;
  }
  if (!Util.isUnset(request.scheduleType)) {
    body['ScheduleType'] = request.scheduleType;
  }
  if (!Util.isUnset(request.scheduleTypeName)) {
    body['ScheduleTypeName'] = request.scheduleTypeName;
  }
  if (!Util.isUnset(request.serviceApiId)) {
    body['ServiceApiId'] = request.serviceApiId;
  }
  if (!Util.isUnset(request.slaveFeatureNum)) {
    body['SlaveFeatureNum'] = request.slaveFeatureNum;
  }
  if (!Util.isUnset(request.trainingJobId)) {
    body['TrainingJobId'] = request.trainingJobId;
  }
  if (!Util.isUnset(request.trainingJobName)) {
    body['TrainingJobName'] = request.trainingJobName;
  }
  if (!Util.isUnset(request.trainingModelId)) {
    body['TrainingModelId'] = request.trainingModelId;
  }
  if (!Util.isUnset(request.trainingModelName)) {
    body['TrainingModelName'] = request.trainingModelName;
  }
  if (!Util.isUnset(request.trainingModelVersion)) {
    body['TrainingModelVersion'] = request.trainingModelVersion;
  }
  if (!Util.isUnset(request.trainingModelVersionName)) {
    body['TrainingModelVersionName'] = request.trainingModelVersionName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateTrustMlPredictionJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createTrustMlPredictionJob(request: CreateTrustMlPredictionJobRequest): CreateTrustMlPredictionJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return createTrustMlPredictionJobWithOptions(request, runtime);
}

model CreateTrustMlTrainingJobRequest {
  algId?: long(name='AlgId'),
  algName?: string(name='AlgName'),
  algRound?: int32(name='AlgRound'),
  algTypeId?: long(name='AlgTypeId'),
  algTypeName?: string(name='AlgTypeName'),
  algVersion?: string(name='AlgVersion'),
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataProcessDtoList?: [ 
    {
      binningCount?: int32(name='BinningCount'),
      binningInterval?: string(name='BinningInterval'),
      binningType?: int32(name='BinningType'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      field?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='Field'),
      processType?: int32(name='ProcessType'),
      processedValue?: string(name='ProcessedValue'),
      rawValues?: [ string ](name='RawValues'),
    }
  ](name='DataProcessDtoList'),
  dataProcessTypeOrder?: [ int32 ](name='DataProcessTypeOrder'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  dynamicParams?: [ 
    {
      checker?: string(name='Checker'),
      displayMode?: string(name='DisplayMode'),
      inputMode?: string(name='InputMode'),
      paramName?: string(name='ParamName'),
      paramNameForDisplay?: string(name='ParamNameForDisplay'),
      paramValue?: string(name='ParamValue'),
    }
  ](name='DynamicParams'),
  featureDistribution?: int32(name='FeatureDistribution'),
  featureFormat?: int32(name='FeatureFormat'),
  gmtCreate?: string(name='GmtCreate'),
  hostFeatureNum?: int32(name='HostFeatureNum'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  partitionType?: int32(name='PartitionType'),
  planList?: [ string ](name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  randomSeed?: int32(name='RandomSeed'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  slaveFeatureNum?: int32(name='SlaveFeatureNum'),
  trainingModelId?: long(name='TrainingModelId'),
  trainingModelName?: string(name='TrainingModelName'),
  trainingModelVersion?: [ string ](name='TrainingModelVersion'),
  trainingModelVersionName?: [ string ](name='TrainingModelVersionName'),
  trainingSetProportion?: int32(name='TrainingSetProportion'),
}

model CreateTrustMlTrainingJobShrinkRequest {
  algId?: long(name='AlgId'),
  algName?: string(name='AlgName'),
  algRound?: int32(name='AlgRound'),
  algTypeId?: long(name='AlgTypeId'),
  algTypeName?: string(name='AlgTypeName'),
  algVersion?: string(name='AlgVersion'),
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataProcessDtoList?: [ 
    {
      binningCount?: int32(name='BinningCount'),
      binningInterval?: string(name='BinningInterval'),
      binningType?: int32(name='BinningType'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      field?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='Field'),
      processType?: int32(name='ProcessType'),
      processedValue?: string(name='ProcessedValue'),
      rawValues?: [ string ](name='RawValues'),
    }
  ](name='DataProcessDtoList'),
  dataProcessTypeOrderShrink?: string(name='DataProcessTypeOrder'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  dynamicParams?: [ 
    {
      checker?: string(name='Checker'),
      displayMode?: string(name='DisplayMode'),
      inputMode?: string(name='InputMode'),
      paramName?: string(name='ParamName'),
      paramNameForDisplay?: string(name='ParamNameForDisplay'),
      paramValue?: string(name='ParamValue'),
    }
  ](name='DynamicParams'),
  featureDistribution?: int32(name='FeatureDistribution'),
  featureFormat?: int32(name='FeatureFormat'),
  gmtCreate?: string(name='GmtCreate'),
  hostFeatureNum?: int32(name='HostFeatureNum'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  partitionType?: int32(name='PartitionType'),
  planListShrink?: string(name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  randomSeed?: int32(name='RandomSeed'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  slaveFeatureNum?: int32(name='SlaveFeatureNum'),
  trainingModelId?: long(name='TrainingModelId'),
  trainingModelName?: string(name='TrainingModelName'),
  trainingModelVersionShrink?: string(name='TrainingModelVersion'),
  trainingModelVersionNameShrink?: string(name='TrainingModelVersionName'),
  trainingSetProportion?: int32(name='TrainingSetProportion'),
}

model CreateTrustMlTrainingJobResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateTrustMlTrainingJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateTrustMlTrainingJobResponseBody(name='body'),
}

async function createTrustMlTrainingJobWithOptions(tmpReq: CreateTrustMlTrainingJobRequest, runtime: Util.RuntimeOptions): CreateTrustMlTrainingJobResponse {
  Util.validateModel(tmpReq);
  var request = new CreateTrustMlTrainingJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.dataProcessTypeOrder)) {
    request.dataProcessTypeOrderShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.dataProcessTypeOrder, 'DataProcessTypeOrder', 'json');
  }
  if (!Util.isUnset(tmpReq.planList)) {
    request.planListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.planList, 'PlanList', 'json');
  }
  if (!Util.isUnset(tmpReq.trainingModelVersion)) {
    request.trainingModelVersionShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.trainingModelVersion, 'TrainingModelVersion', 'json');
  }
  if (!Util.isUnset(tmpReq.trainingModelVersionName)) {
    request.trainingModelVersionNameShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.trainingModelVersionName, 'TrainingModelVersionName', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.algId)) {
    body['AlgId'] = request.algId;
  }
  if (!Util.isUnset(request.algName)) {
    body['AlgName'] = request.algName;
  }
  if (!Util.isUnset(request.algRound)) {
    body['AlgRound'] = request.algRound;
  }
  if (!Util.isUnset(request.algTypeId)) {
    body['AlgTypeId'] = request.algTypeId;
  }
  if (!Util.isUnset(request.algTypeName)) {
    body['AlgTypeName'] = request.algTypeName;
  }
  if (!Util.isUnset(request.algVersion)) {
    body['AlgVersion'] = request.algVersion;
  }
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.configuration)) {
    body['Configuration'] = request.configuration;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.dataProcessDtoList)) {
    body['DataProcessDtoList'] = request.dataProcessDtoList;
  }
  if (!Util.isUnset(request.dataProcessTypeOrderShrink)) {
    body['DataProcessTypeOrder'] = request.dataProcessTypeOrderShrink;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.dynamicParams)) {
    body['DynamicParams'] = request.dynamicParams;
  }
  if (!Util.isUnset(request.featureDistribution)) {
    body['FeatureDistribution'] = request.featureDistribution;
  }
  if (!Util.isUnset(request.featureFormat)) {
    body['FeatureFormat'] = request.featureFormat;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.hostFeatureNum)) {
    body['HostFeatureNum'] = request.hostFeatureNum;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobStatus)) {
    body['JobStatus'] = request.jobStatus;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modeName)) {
    body['ModeName'] = request.modeName;
  }
  if (!Util.isUnset(request.partitionType)) {
    body['PartitionType'] = request.partitionType;
  }
  if (!Util.isUnset(request.planListShrink)) {
    body['PlanList'] = request.planListShrink;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.protocolTypeList)) {
    body['ProtocolTypeList'] = request.protocolTypeList;
  }
  if (!Util.isUnset(request.randomSeed)) {
    body['RandomSeed'] = request.randomSeed;
  }
  if (!Util.isUnset(request.scheduleCron)) {
    body['ScheduleCron'] = request.scheduleCron;
  }
  if (!Util.isUnset(request.scheduleType)) {
    body['ScheduleType'] = request.scheduleType;
  }
  if (!Util.isUnset(request.scheduleTypeName)) {
    body['ScheduleTypeName'] = request.scheduleTypeName;
  }
  if (!Util.isUnset(request.slaveFeatureNum)) {
    body['SlaveFeatureNum'] = request.slaveFeatureNum;
  }
  if (!Util.isUnset(request.trainingModelId)) {
    body['TrainingModelId'] = request.trainingModelId;
  }
  if (!Util.isUnset(request.trainingModelName)) {
    body['TrainingModelName'] = request.trainingModelName;
  }
  if (!Util.isUnset(request.trainingModelVersionShrink)) {
    body['TrainingModelVersion'] = request.trainingModelVersionShrink;
  }
  if (!Util.isUnset(request.trainingModelVersionNameShrink)) {
    body['TrainingModelVersionName'] = request.trainingModelVersionNameShrink;
  }
  if (!Util.isUnset(request.trainingSetProportion)) {
    body['TrainingSetProportion'] = request.trainingSetProportion;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateTrustMlTrainingJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createTrustMlTrainingJob(request: CreateTrustMlTrainingJobRequest): CreateTrustMlTrainingJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return createTrustMlTrainingJobWithOptions(request, runtime);
}

model CsccSystemInitRequest {
  extendId?: string(name='ExtendId'),
}

model CsccSystemInitResponseBody = {
  code?: long(name='Code'),
  data?: {
    dataSourceId?: string(name='DataSourceId'),
    encryptPubKey?: string(name='EncryptPubKey'),
    instanceId?: string(name='InstanceId'),
    memberId?: long(name='MemberId'),
    teeUserId?: string(name='TeeUserId'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CsccSystemInitResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CsccSystemInitResponseBody(name='body'),
}

async function csccSystemInitWithOptions(request: CsccSystemInitRequest, runtime: Util.RuntimeOptions): CsccSystemInitResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.extendId)) {
    body['ExtendId'] = request.extendId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CsccSystemInit',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function csccSystemInit(request: CsccSystemInitRequest): CsccSystemInitResponse {
  var runtime = new Util.RuntimeOptions{};
  return csccSystemInitWithOptions(request, runtime);
}

model DeleteBatchProjectMetaRequest {
  projectId?: long(name='ProjectId'),
  tableIdList?: [ long ](name='TableIdList'),
}

model DeleteBatchProjectMetaResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      errMsg?: string(name='ErrMsg'),
      targetTableId?: long(name='TargetTableId'),
      targetTableName?: string(name='TargetTableName'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DeleteBatchProjectMetaResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteBatchProjectMetaResponseBody(name='body'),
}

async function deleteBatchProjectMetaWithOptions(request: DeleteBatchProjectMetaRequest, runtime: Util.RuntimeOptions): DeleteBatchProjectMetaResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.tableIdList)) {
    body['TableIdList'] = request.tableIdList;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteBatchProjectMeta',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteBatchProjectMeta(request: DeleteBatchProjectMetaRequest): DeleteBatchProjectMetaResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteBatchProjectMetaWithOptions(request, runtime);
}

model DeleteCsccJobRequest {
  approvalStatus?: string(name='ApprovalStatus'),
  creatorId?: long(name='CreatorId'),
  creatorName?: string(name='CreatorName'),
  deleteStatus?: int32(name='DeleteStatus'),
  endDate?: string(name='EndDate'),
  gmtModified?: string(name='GmtModified'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  projectId?: long(name='ProjectId'),
  runStatus?: int32(name='RunStatus'),
  startDate?: string(name='StartDate'),
  updateStatus?: int32(name='UpdateStatus'),
}

model DeleteCsccJobResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DeleteCsccJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteCsccJobResponseBody(name='body'),
}

async function deleteCsccJobWithOptions(request: DeleteCsccJobRequest, runtime: Util.RuntimeOptions): DeleteCsccJobResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.creatorName)) {
    body['CreatorName'] = request.creatorName;
  }
  if (!Util.isUnset(request.deleteStatus)) {
    body['DeleteStatus'] = request.deleteStatus;
  }
  if (!Util.isUnset(request.endDate)) {
    body['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.gmtModified)) {
    body['GmtModified'] = request.gmtModified;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.runStatus)) {
    body['RunStatus'] = request.runStatus;
  }
  if (!Util.isUnset(request.startDate)) {
    body['StartDate'] = request.startDate;
  }
  if (!Util.isUnset(request.updateStatus)) {
    body['UpdateStatus'] = request.updateStatus;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteCsccJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteCsccJob(request: DeleteCsccJobRequest): DeleteCsccJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteCsccJobWithOptions(request, runtime);
}

model DeleteMetaRequest {
  lsccTableId?: long(name='LsccTableId'),
}

model DeleteMetaResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DeleteMetaResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteMetaResponseBody(name='body'),
}

async function deleteMetaWithOptions(request: DeleteMetaRequest, runtime: Util.RuntimeOptions): DeleteMetaResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.lsccTableId)) {
    body['LsccTableId'] = request.lsccTableId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteMeta',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteMeta(request: DeleteMetaRequest): DeleteMetaResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteMetaWithOptions(request, runtime);
}

model DeleteOnlineServiceRequest {
  approvalStatus?: string(name='ApprovalStatus'),
  creatorId?: long(name='CreatorId'),
  creatorName?: string(name='CreatorName'),
  deleteStatus?: int32(name='DeleteStatus'),
  endDate?: string(name='EndDate'),
  gmtModified?: string(name='GmtModified'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  projectId?: long(name='ProjectId'),
  runStatus?: int32(name='RunStatus'),
  startDate?: string(name='StartDate'),
  updateStatus?: int32(name='UpdateStatus'),
}

model DeleteOnlineServiceResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DeleteOnlineServiceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteOnlineServiceResponseBody(name='body'),
}

async function deleteOnlineServiceWithOptions(request: DeleteOnlineServiceRequest, runtime: Util.RuntimeOptions): DeleteOnlineServiceResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.creatorName)) {
    body['CreatorName'] = request.creatorName;
  }
  if (!Util.isUnset(request.deleteStatus)) {
    body['DeleteStatus'] = request.deleteStatus;
  }
  if (!Util.isUnset(request.endDate)) {
    body['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.gmtModified)) {
    body['GmtModified'] = request.gmtModified;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.runStatus)) {
    body['RunStatus'] = request.runStatus;
  }
  if (!Util.isUnset(request.startDate)) {
    body['StartDate'] = request.startDate;
  }
  if (!Util.isUnset(request.updateStatus)) {
    body['UpdateStatus'] = request.updateStatus;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteOnlineService',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteOnlineService(request: DeleteOnlineServiceRequest): DeleteOnlineServiceResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteOnlineServiceWithOptions(request, runtime);
}

model DeleteProjectRequest {
  projectId?: long(name='ProjectId'),
}

model DeleteProjectResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DeleteProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteProjectResponseBody(name='body'),
}

async function deleteProjectWithOptions(request: DeleteProjectRequest, runtime: Util.RuntimeOptions): DeleteProjectResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteProject',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteProject(request: DeleteProjectRequest): DeleteProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteProjectWithOptions(request, runtime);
}

model DeleteProjectMetaRequest {
  projectId?: long(name='ProjectId'),
  tableId?: long(name='TableId'),
}

model DeleteProjectMetaResponseBody = {
  code?: long(name='Code'),
  data?: long(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DeleteProjectMetaResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteProjectMetaResponseBody(name='body'),
}

async function deleteProjectMetaWithOptions(request: DeleteProjectMetaRequest, runtime: Util.RuntimeOptions): DeleteProjectMetaResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.tableId)) {
    body['TableId'] = request.tableId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteProjectMeta',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteProjectMeta(request: DeleteProjectMetaRequest): DeleteProjectMetaResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteProjectMetaWithOptions(request, runtime);
}

model ExitProjectRequest {
  projectId?: long(name='ProjectId'),
}

model ExitProjectResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ExitProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ExitProjectResponseBody(name='body'),
}

async function exitProjectWithOptions(request: ExitProjectRequest, runtime: Util.RuntimeOptions): ExitProjectResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ExitProject',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function exitProject(request: ExitProjectRequest): ExitProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return exitProjectWithOptions(request, runtime);
}

model GetCsccApprovalDetailRequest {
  approvalId?: long(name='ApprovalId'),
}

model GetCsccApprovalDetailResponseBody = {
  code?: long(name='Code'),
  data?: string(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetCsccApprovalDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetCsccApprovalDetailResponseBody(name='body'),
}

async function getCsccApprovalDetailWithOptions(request: GetCsccApprovalDetailRequest, runtime: Util.RuntimeOptions): GetCsccApprovalDetailResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetCsccApprovalDetail',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCsccApprovalDetail(request: GetCsccApprovalDetailRequest): GetCsccApprovalDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCsccApprovalDetailWithOptions(request, runtime);
}

model GetCsccApprovalFlowRequest {
  approvalId?: long(name='ApprovalId'),
}

model GetCsccApprovalFlowResponseBody = {
  code?: long(name='Code'),
  data?: {
    approverDtos?: [ 
      {
        approvalAction?: string(name='ApprovalAction'),
        approvalId?: long(name='ApprovalId'),
        approvalState?: int32(name='ApprovalState'),
        approvalStateName?: string(name='ApprovalStateName'),
        approvalType?: int32(name='ApprovalType'),
        approvalTypeName?: string(name='ApprovalTypeName'),
        approverId?: long(name='ApproverId'),
        approverName?: string(name='ApproverName'),
        approverUserId?: long(name='ApproverUserId'),
        companyName?: string(name='CompanyName'),
        current?: boolean(name='Current'),
        description?: string(name='Description'),
        extend?: string(name='Extend'),
        fullCompanyName?: string(name='FullCompanyName'),
        gmtCreate?: long(name='GmtCreate'),
        gmtModified?: string(name='GmtModified'),
        id?: long(name='Id'),
        jobId?: long(name='JobId'),
        jobName?: string(name='JobName'),
        projectId?: long(name='ProjectId'),
        projectName?: string(name='ProjectName'),
        proposerId?: long(name='ProposerId'),
        proposerName?: string(name='ProposerName'),
        runEnvApprovalId?: string(name='RunEnvApprovalId'),
        runEnvJobId?: string(name='RunEnvJobId'),
        serviceHost?: string(name='ServiceHost'),
        servicePort?: string(name='ServicePort'),
        sign?: string(name='Sign'),
        snapShot?: string(name='SnapShot'),
        token?: string(name='Token'),
        transportHost?: string(name='TransportHost'),
        transportPort?: string(name='TransportPort'),
      }
    ](name='ApproverDtos'),
    cancelPermission?: boolean(name='CancelPermission'),
    submitPermission?: boolean(name='SubmitPermission'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetCsccApprovalFlowResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetCsccApprovalFlowResponseBody(name='body'),
}

async function getCsccApprovalFlowWithOptions(request: GetCsccApprovalFlowRequest, runtime: Util.RuntimeOptions): GetCsccApprovalFlowResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetCsccApprovalFlow',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCsccApprovalFlow(request: GetCsccApprovalFlowRequest): GetCsccApprovalFlowResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCsccApprovalFlowWithOptions(request, runtime);
}

model GetCsccApprovalInfoRequest {
  approvalId?: long(name='ApprovalId'),
}

model GetCsccApprovalInfoResponseBody = {
  code?: long(name='Code'),
  data?: {
    approvalId?: long(name='ApprovalId'),
    approvalState?: int32(name='ApprovalState'),
    approvalStateName?: string(name='ApprovalStateName'),
    approvalType?: int32(name='ApprovalType'),
    approvalTypeName?: string(name='ApprovalTypeName'),
    companyName?: string(name='CompanyName'),
    fullCompanyName?: string(name='FullCompanyName'),
    gmtCreate?: long(name='GmtCreate'),
    id?: long(name='Id'),
    jobId?: long(name='JobId'),
    jobName?: string(name='JobName'),
    projectId?: long(name='ProjectId'),
    projectName?: string(name='ProjectName'),
    proposerId?: long(name='ProposerId'),
    proposerName?: string(name='ProposerName'),
    serviceHost?: string(name='ServiceHost'),
    servicePort?: string(name='ServicePort'),
    snapShot?: string(name='SnapShot'),
    token?: string(name='Token'),
    transportHost?: string(name='TransportHost'),
    transportPort?: string(name='TransportPort'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetCsccApprovalInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetCsccApprovalInfoResponseBody(name='body'),
}

async function getCsccApprovalInfoWithOptions(request: GetCsccApprovalInfoRequest, runtime: Util.RuntimeOptions): GetCsccApprovalInfoResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetCsccApprovalInfo',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCsccApprovalInfo(request: GetCsccApprovalInfoRequest): GetCsccApprovalInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCsccApprovalInfoWithOptions(request, runtime);
}

model GetCsccApprovalStatsResponseBody = {
  code?: long(name='Code'),
  data?: {
    doneNum?: int32(name='DoneNum'),
    pendingNum?: int32(name='PendingNum'),
    proposedNum?: int32(name='ProposedNum'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetCsccApprovalStatsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetCsccApprovalStatsResponseBody(name='body'),
}

async function getCsccApprovalStatsWithOptions(runtime: Util.RuntimeOptions): GetCsccApprovalStatsResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'GetCsccApprovalStats',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCsccApprovalStats(): GetCsccApprovalStatsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCsccApprovalStatsWithOptions(runtime);
}

model GetCsccInfoRequest {
  extendId?: string(name='ExtendId'),
  projectId?: long(name='ProjectId'),
}

model GetCsccInfoResponseBody = {
  code?: long(name='Code'),
  data?: {
    csccOpen?: boolean(name='CsccOpen'),
    flOpen?: boolean(name='FlOpen'),
    maxVersion?: string(name='MaxVersion'),
    mpcOpen?: boolean(name='MpcOpen'),
    sandBoxOpen?: boolean(name='SandBoxOpen'),
    teeOpen?: boolean(name='TeeOpen'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetCsccInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetCsccInfoResponseBody(name='body'),
}

async function getCsccInfoWithOptions(request: GetCsccInfoRequest, runtime: Util.RuntimeOptions): GetCsccInfoResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.extendId)) {
    body['ExtendId'] = request.extendId;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetCsccInfo',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCsccInfo(request: GetCsccInfoRequest): GetCsccInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCsccInfoWithOptions(request, runtime);
}

model GetCsccJobInstanceRequest {
  jobInstanceId?: long(name='JobInstanceId'),
}

model GetCsccJobInstanceResponseBody = {
  code?: long(name='Code'),
  data?: {
    end?: string(name='End'),
    gmtCreate?: string(name='GmtCreate'),
    gmtModified?: string(name='GmtModified'),
    id?: long(name='Id'),
    jobId?: long(name='JobId'),
    jobInstanceStatus?: int32(name='JobInstanceStatus'),
    jobInstanceType?: int32(name='JobInstanceType'),
    jobInstanceTypeName?: string(name='JobInstanceTypeName'),
    jobModel?: int32(name='JobModel'),
    jobName?: string(name='JobName'),
    jobType?: int32(name='JobType'),
    projectName?: string(name='ProjectName'),
    runTime?: string(name='RunTime'),
    scheduleDs?: string(name='ScheduleDs'),
    start?: string(name='Start'),
    statusClassify?: int32(name='StatusClassify'),
    strRunTime?: string(name='StrRunTime'),
    typeClassify?: int32(name='TypeClassify'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetCsccJobInstanceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetCsccJobInstanceResponseBody(name='body'),
}

async function getCsccJobInstanceWithOptions(request: GetCsccJobInstanceRequest, runtime: Util.RuntimeOptions): GetCsccJobInstanceResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobInstanceId)) {
    body['JobInstanceId'] = request.jobInstanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetCsccJobInstance',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCsccJobInstance(request: GetCsccJobInstanceRequest): GetCsccJobInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCsccJobInstanceWithOptions(request, runtime);
}

model GetCsccProposerNameRequest {
  memberId?: long(name='MemberId'),
}

model GetCsccProposerNameResponseBody = {
  code?: long(name='Code'),
  data?: string(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetCsccProposerNameResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetCsccProposerNameResponseBody(name='body'),
}

async function getCsccProposerNameWithOptions(request: GetCsccProposerNameRequest, runtime: Util.RuntimeOptions): GetCsccProposerNameResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.memberId)) {
    body['MemberId'] = request.memberId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetCsccProposerName',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCsccProposerName(request: GetCsccProposerNameRequest): GetCsccProposerNameResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCsccProposerNameWithOptions(request, runtime);
}

model GetDefaultTrustMlDataProcessConfigRequest {
  algName?: string(name='AlgName'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  featureFormat?: int32(name='FeatureFormat'),
  jobId?: long(name='JobId'),
  jobType?: int32(name='JobType'),
  projectId?: long(name='ProjectId'),
  trainingJobId?: long(name='TrainingJobId'),
}

model GetDefaultTrustMlDataProcessConfigResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      binningCount?: int32(name='BinningCount'),
      binningInterval?: string(name='BinningInterval'),
      binningType?: int32(name='BinningType'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      field?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='Field'),
      processType?: int32(name='ProcessType'),
      processedValue?: string(name='ProcessedValue'),
      rawValues?: [ string ](name='RawValues'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetDefaultTrustMlDataProcessConfigResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetDefaultTrustMlDataProcessConfigResponseBody(name='body'),
}

async function getDefaultTrustMlDataProcessConfigWithOptions(request: GetDefaultTrustMlDataProcessConfigRequest, runtime: Util.RuntimeOptions): GetDefaultTrustMlDataProcessConfigResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.algName)) {
    body['AlgName'] = request.algName;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.featureFormat)) {
    body['FeatureFormat'] = request.featureFormat;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.trainingJobId)) {
    body['TrainingJobId'] = request.trainingJobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetDefaultTrustMlDataProcessConfig',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getDefaultTrustMlDataProcessConfig(request: GetDefaultTrustMlDataProcessConfigRequest): GetDefaultTrustMlDataProcessConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return getDefaultTrustMlDataProcessConfigWithOptions(request, runtime);
}

model GetHistoryFlTrainingJobInstanceByJobIdRequest {
  jobId?: long(name='JobId'),
}

model GetHistoryFlTrainingJobInstanceByJobIdResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      algId?: long(name='AlgId'),
      algName?: string(name='AlgName'),
      algRound?: int32(name='AlgRound'),
      algTypeId?: long(name='AlgTypeId'),
      algTypeName?: string(name='AlgTypeName'),
      algVersion?: string(name='AlgVersion'),
      approvalId?: long(name='ApprovalId'),
      approvalStatus?: int32(name='ApprovalStatus'),
      configuration?: string(name='Configuration'),
      creatorId?: long(name='CreatorId'),
      dataProcessDtoList?: [ 
        {
          binningCount?: int32(name='BinningCount'),
          binningInterval?: string(name='BinningInterval'),
          binningType?: int32(name='BinningType'),
          dataOwnerId?: long(name='DataOwnerId'),
          dataOwnerName?: string(name='DataOwnerName'),
          dataSetId?: long(name='DataSetId'),
          dataSetName?: string(name='DataSetName'),
          dataSetUsage?: int32(name='DataSetUsage'),
          field?: [ 
            {
              columnDataType?: string(name='ColumnDataType'),
              columnDesc?: string(name='ColumnDesc'),
              columnName?: string(name='ColumnName'),
              isPartitionColumn?: boolean(name='IsPartitionColumn'),
            }
          ](name='Field'),
          processType?: int32(name='ProcessType'),
          processedValue?: string(name='ProcessedValue'),
          rawValues?: [ string ](name='RawValues'),
        }
      ](name='DataProcessDtoList'),
      dataProcessTypeOrder?: [ int32 ](name='DataProcessTypeOrder'),
      dataSetDtos?: [ 
        {
          columns?: [ string ](name='Columns'),
          dataOwnerId?: long(name='DataOwnerId'),
          dataOwnerName?: string(name='DataOwnerName'),
          dataRole?: int32(name='DataRole'),
          dataSetId?: long(name='DataSetId'),
          dataSetName?: string(name='DataSetName'),
          dataSetUsage?: int32(name='DataSetUsage'),
          filterStr?: string(name='FilterStr'),
          flFeatureColumns?: [ 
            {
              columnDataType?: string(name='ColumnDataType'),
              columnDesc?: string(name='ColumnDesc'),
              columnName?: string(name='ColumnName'),
              isPartitionColumn?: boolean(name='IsPartitionColumn'),
            }
          ](name='FlFeatureColumns'),
          flLabelColumn?: string(name='FlLabelColumn'),
          inputColumns?: [ 
            {
              dataSetRole?: int32(name='DataSetRole'),
              dataType?: string(name='DataType'),
              inputColumnDesc?: string(name='InputColumnDesc'),
              inputColumnName?: string(name='InputColumnName'),
              outputColumnDesc?: string(name='OutputColumnDesc'),
              outputColumnName?: string(name='OutputColumnName'),
            }
          ](name='InputColumns'),
          inputDs?: string(name='InputDs'),
          order?: int32(name='Order'),
          outputColumns?: [ 
            {
              dataSetRole?: int32(name='DataSetRole'),
              dataType?: string(name='DataType'),
              inputColumnDesc?: string(name='InputColumnDesc'),
              inputColumnName?: string(name='InputColumnName'),
              outputColumnDesc?: string(name='OutputColumnDesc'),
              outputColumnName?: string(name='OutputColumnName'),
            }
          ](name='OutputColumns'),
          outputDataSetId?: long(name='OutputDataSetId'),
          outputDs?: string(name='OutputDs'),
          outputName?: string(name='OutputName'),
          preSql?: string(name='PreSql'),
        }
      ](name='DataSetDtos'),
      dynamicParams?: [ 
        {
          checker?: string(name='Checker'),
          displayMode?: string(name='DisplayMode'),
          inputMode?: string(name='InputMode'),
          paramName?: string(name='ParamName'),
          paramNameForDisplay?: string(name='ParamNameForDisplay'),
          paramValue?: string(name='ParamValue'),
        }
      ](name='DynamicParams'),
      featureDistribution?: int32(name='FeatureDistribution'),
      featureFormat?: int32(name='FeatureFormat'),
      gmtCreate?: string(name='GmtCreate'),
      hostFeatureNum?: int32(name='HostFeatureNum'),
      jobId?: long(name='JobId'),
      jobName?: string(name='JobName'),
      jobStatus?: int32(name='JobStatus'),
      jobType?: int32(name='JobType'),
      jobTypeName?: string(name='JobTypeName'),
      mode?: int32(name='Mode'),
      modeName?: string(name='ModeName'),
      partitionType?: int32(name='PartitionType'),
      planList?: [ string ](name='PlanList'),
      projectId?: long(name='ProjectId'),
      projectName?: string(name='ProjectName'),
      protocolTypeList?: [ string ](name='ProtocolTypeList'),
      randomSeed?: int32(name='RandomSeed'),
      scheduleCron?: string(name='ScheduleCron'),
      scheduleType?: int32(name='ScheduleType'),
      scheduleTypeName?: string(name='ScheduleTypeName'),
      slaveFeatureNum?: int32(name='SlaveFeatureNum'),
      trainingModelId?: long(name='TrainingModelId'),
      trainingModelName?: string(name='TrainingModelName'),
      trainingModelVersion?: [ string ](name='TrainingModelVersion'),
      trainingModelVersionName?: [ string ](name='TrainingModelVersionName'),
      trainingSetProportion?: int32(name='TrainingSetProportion'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetHistoryFlTrainingJobInstanceByJobIdResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetHistoryFlTrainingJobInstanceByJobIdResponseBody(name='body'),
}

async function getHistoryFlTrainingJobInstanceByJobIdWithOptions(request: GetHistoryFlTrainingJobInstanceByJobIdRequest, runtime: Util.RuntimeOptions): GetHistoryFlTrainingJobInstanceByJobIdResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetHistoryFlTrainingJobInstanceByJobId',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getHistoryFlTrainingJobInstanceByJobId(request: GetHistoryFlTrainingJobInstanceByJobIdRequest): GetHistoryFlTrainingJobInstanceByJobIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return getHistoryFlTrainingJobInstanceByJobIdWithOptions(request, runtime);
}

model GetHistoryPsiPreCacheJobsForJobMembersRequest {
  jobName?: string(name='JobName'),
  memberId1?: long(name='MemberId1'),
  memberId2?: long(name='MemberId2'),
  projectId?: long(name='ProjectId'),
}

model GetHistoryPsiPreCacheJobsForJobMembersResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      cacheUsage?: long(name='CacheUsage'),
      isUsePsiPreCache?: boolean(name='IsUsePsiPreCache'),
      localBasePath?: string(name='LocalBasePath'),
      psiPreCacheColumn?: [ string ](name='PsiPreCacheColumn'),
      psiPreCacheDataName?: string(name='PsiPreCacheDataName'),
      psiPreCacheJobId?: long(name='PsiPreCacheJobId'),
      psiPreCacheJobName?: string(name='PsiPreCacheJobName'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetHistoryPsiPreCacheJobsForJobMembersResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetHistoryPsiPreCacheJobsForJobMembersResponseBody(name='body'),
}

async function getHistoryPsiPreCacheJobsForJobMembersWithOptions(request: GetHistoryPsiPreCacheJobsForJobMembersRequest, runtime: Util.RuntimeOptions): GetHistoryPsiPreCacheJobsForJobMembersResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.memberId1)) {
    body['MemberId1'] = request.memberId1;
  }
  if (!Util.isUnset(request.memberId2)) {
    body['MemberId2'] = request.memberId2;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetHistoryPsiPreCacheJobsForJobMembers',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getHistoryPsiPreCacheJobsForJobMembers(request: GetHistoryPsiPreCacheJobsForJobMembersRequest): GetHistoryPsiPreCacheJobsForJobMembersResponse {
  var runtime = new Util.RuntimeOptions{};
  return getHistoryPsiPreCacheJobsForJobMembersWithOptions(request, runtime);
}

model GetJobInfoRequest {
  jobId?: long(name='JobId'),
  jobInstanceId?: long(name='JobInstanceId'),
}

model GetJobInfoResponseBody = {
  code?: long(name='Code'),
  data?: {
    approvalId?: long(name='ApprovalId'),
    approvalStatus?: int32(name='ApprovalStatus'),
    configuration?: string(name='Configuration'),
    creatorId?: long(name='CreatorId'),
    gmtCreate?: string(name='GmtCreate'),
    jobId?: long(name='JobId'),
    jobName?: string(name='JobName'),
    jobStatus?: int32(name='JobStatus'),
    jobType?: int32(name='JobType'),
    jobTypeName?: string(name='JobTypeName'),
    mode?: int32(name='Mode'),
    modeName?: string(name='ModeName'),
    projectId?: long(name='ProjectId'),
    projectName?: string(name='ProjectName'),
    scheduleCron?: string(name='ScheduleCron'),
    scheduleType?: int32(name='ScheduleType'),
    scheduleTypeName?: string(name='ScheduleTypeName'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetJobInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetJobInfoResponseBody(name='body'),
}

async function getJobInfoWithOptions(request: GetJobInfoRequest, runtime: Util.RuntimeOptions): GetJobInfoResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobInstanceId)) {
    body['JobInstanceId'] = request.jobInstanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetJobInfo',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getJobInfo(request: GetJobInfoRequest): GetJobInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getJobInfoWithOptions(request, runtime);
}

model GetJobInstanceRunLogRequest {
  logId?: long(name='LogId'),
  verbose?: boolean(name='Verbose'),
}

model GetJobInstanceRunLogResponseBody = {
  code?: long(name='Code'),
  data?: {
    extInfo?: string(name='ExtInfo'),
    gmtCreate?: string(name='GmtCreate'),
    gmtModified?: string(name='GmtModified'),
    hostFeatureImportance?: string(name='HostFeatureImportance'),
    id?: long(name='Id'),
    instanceId?: long(name='InstanceId'),
    instanceStatus?: int32(name='InstanceStatus'),
    jobId?: long(name='JobId'),
    jobType?: int32(name='JobType'),
    log?: string(name='Log'),
    memberId?: long(name='MemberId'),
    progress?: int32(name='Progress'),
    slaveFeatureImportance?: string(name='SlaveFeatureImportance'),
    stageDetail?: [ 
      {
        account?: string(name='Account'),
        memberId?: long(name='MemberId'),
        role?: int32(name='Role'),
        stage?: [ 
          {
            endTime?: string(name='EndTime'),
            name?: string(name='Name'),
            progress?: double(name='Progress'),
            runLog?: string(name='RunLog'),
            startTime?: string(name='StartTime'),
            status?: int32(name='Status'),
            step?: int32(name='Step'),
            type?: string(name='Type'),
            typeAlias?: string(name='TypeAlias'),
          }
        ](name='Stage'),
      }
    ](name='StageDetail'),
    stageRelation?: [ 
      {
        fromMemberId?: long(name='FromMemberId'),
        fromStep?: int32(name='FromStep'),
        toMemberId?: long(name='ToMemberId'),
        toStep?: int32(name='ToStep'),
      }
    ](name='StageRelation'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetJobInstanceRunLogResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetJobInstanceRunLogResponseBody(name='body'),
}

async function getJobInstanceRunLogWithOptions(request: GetJobInstanceRunLogRequest, runtime: Util.RuntimeOptions): GetJobInstanceRunLogResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.logId)) {
    body['LogId'] = request.logId;
  }
  if (!Util.isUnset(request.verbose)) {
    body['Verbose'] = request.verbose;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetJobInstanceRunLog',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getJobInstanceRunLog(request: GetJobInstanceRunLogRequest): GetJobInstanceRunLogResponse {
  var runtime = new Util.RuntimeOptions{};
  return getJobInstanceRunLogWithOptions(request, runtime);
}

model GetJobInstanceSummaryRequest {
  logId?: long(name='LogId'),
}

model GetJobInstanceSummaryResponseBody = {
  code?: long(name='Code'),
  data?: {
    gmtCreate?: string(name='GmtCreate'),
    gmtModified?: string(name='GmtModified'),
    id?: long(name='Id'),
    instanceId?: long(name='InstanceId'),
    jobId?: long(name='JobId'),
    memberId?: long(name='MemberId'),
    modelEvaluation?: [ 
      {
        accuracy?: {
          alias?: string(name='Alias'),
          key?: string(name='Key'),
          value?: double(name='Value'),
        }(name='Accuracy'),
        auc?: double(name='Auc'),
        f1Score?: {
          alias?: string(name='Alias'),
          key?: string(name='Key'),
          value?: double(name='Value'),
        }(name='F1Score'),
        indicators?: [ 
          {
            alias?: string(name='Alias'),
            key?: string(name='Key'),
            value?: double(name='Value'),
          }
        ](name='Indicators'),
        ks?: {
          fpr?: [ double ](name='Fpr'),
          threshold?: [ double ](name='Threshold'),
          tpr?: [ double ](name='Tpr'),
        }(name='Ks'),
        ksIndex?: int32(name='KsIndex'),
        ksValue?: double(name='KsValue'),
        loss?: {
          alias?: string(name='Alias'),
          key?: string(name='Key'),
          value?: double(name='Value'),
        }(name='Loss'),
        model?: string(name='Model'),
        mse?: {
          alias?: string(name='Alias'),
          key?: string(name='Key'),
          value?: double(name='Value'),
        }(name='Mse'),
        precision?: {
          alias?: string(name='Alias'),
          key?: string(name='Key'),
          value?: double(name='Value'),
        }(name='Precision'),
        recall?: {
          alias?: string(name='Alias'),
          key?: string(name='Key'),
          value?: double(name='Value'),
        }(name='Recall'),
        roc?: {
          fpr?: [ double ](name='Fpr'),
          tpr?: [ double ](name='Tpr'),
        }(name='Roc'),
        version?: string(name='Version'),
      }
    ](name='ModelEvaluation'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetJobInstanceSummaryResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetJobInstanceSummaryResponseBody(name='body'),
}

async function getJobInstanceSummaryWithOptions(request: GetJobInstanceSummaryRequest, runtime: Util.RuntimeOptions): GetJobInstanceSummaryResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.logId)) {
    body['LogId'] = request.logId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetJobInstanceSummary',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getJobInstanceSummary(request: GetJobInstanceSummaryRequest): GetJobInstanceSummaryResponse {
  var runtime = new Util.RuntimeOptions{};
  return getJobInstanceSummaryWithOptions(request, runtime);
}

model GetModelingRequest {
  modelingId?: long(name='ModelingId'),
}

model GetModelingResponseBody = {
  code?: long(name='Code'),
  data?: {
    args?: string(name='Args'),
    classificationId?: long(name='ClassificationId'),
    classificationName?: string(name='ClassificationName'),
    description?: string(name='Description'),
    gmtModified?: string(name='GmtModified'),
    imageId?: string(name='ImageId'),
    modelingId?: long(name='ModelingId'),
    modelingName?: string(name='ModelingName'),
    modelingType?: int32(name='ModelingType'),
    modelingVersion?: string(name='ModelingVersion'),
    paramDefinition?: string(name='ParamDefinition'),
    paramDefinitionDetails?: [ 
      {
        candidates?: [ string ](name='Candidates'),
        checker?: {
          format?: string(name='Format'),
          type?: string(name='Type'),
        }(name='Checker'),
        defaultValue?: string(name='DefaultValue'),
        displayMode?: string(name='DisplayMode'),
        inputMode?: string(name='InputMode'),
        paramDescription?: string(name='ParamDescription'),
        paramName?: string(name='ParamName'),
        paramNameForDisplay?: string(name='ParamNameForDisplay'),
      }
    ](name='ParamDefinitionDetails'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetModelingResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetModelingResponseBody(name='body'),
}

async function getModelingWithOptions(request: GetModelingRequest, runtime: Util.RuntimeOptions): GetModelingResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.modelingId)) {
    body['ModelingId'] = request.modelingId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetModeling',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getModeling(request: GetModelingRequest): GetModelingResponse {
  var runtime = new Util.RuntimeOptions{};
  return getModelingWithOptions(request, runtime);
}

model GetMpcPrivateIdJobRequest {
  jobId?: long(name='JobId'),
}

model GetMpcPrivateIdJobResponseBody = {
  code?: long(name='Code'),
  data?: {
    approvalId?: long(name='ApprovalId'),
    approvalStatus?: int32(name='ApprovalStatus'),
    configuration?: string(name='Configuration'),
    creatorId?: long(name='CreatorId'),
    dataSetDtos?: [ 
      {
        columns?: [ string ](name='Columns'),
        dataOwnerId?: long(name='DataOwnerId'),
        dataOwnerName?: string(name='DataOwnerName'),
        dataRole?: int32(name='DataRole'),
        dataSetId?: long(name='DataSetId'),
        dataSetName?: string(name='DataSetName'),
        dataSetUsage?: int32(name='DataSetUsage'),
        filterStr?: string(name='FilterStr'),
        flFeatureColumns?: [ 
          {
            columnDataType?: string(name='ColumnDataType'),
            columnDesc?: string(name='ColumnDesc'),
            columnName?: string(name='ColumnName'),
            isPartitionColumn?: boolean(name='IsPartitionColumn'),
          }
        ](name='FlFeatureColumns'),
        flLabelColumn?: string(name='FlLabelColumn'),
        inputColumns?: [ 
          {
            dataSetRole?: int32(name='DataSetRole'),
            dataType?: string(name='DataType'),
            inputColumnDesc?: string(name='InputColumnDesc'),
            inputColumnName?: string(name='InputColumnName'),
            outputColumnDesc?: string(name='OutputColumnDesc'),
            outputColumnName?: string(name='OutputColumnName'),
          }
        ](name='InputColumns'),
        inputDs?: string(name='InputDs'),
        order?: int32(name='Order'),
        outputColumns?: [ 
          {
            dataSetRole?: int32(name='DataSetRole'),
            dataType?: string(name='DataType'),
            inputColumnDesc?: string(name='InputColumnDesc'),
            inputColumnName?: string(name='InputColumnName'),
            outputColumnDesc?: string(name='OutputColumnDesc'),
            outputColumnName?: string(name='OutputColumnName'),
          }
        ](name='OutputColumns'),
        outputDataSetId?: long(name='OutputDataSetId'),
        outputDs?: string(name='OutputDs'),
        outputName?: string(name='OutputName'),
        preSql?: string(name='PreSql'),
      }
    ](name='DataSetDtos'),
    gmtCreate?: string(name='GmtCreate'),
    jobId?: long(name='JobId'),
    jobName?: string(name='JobName'),
    jobStatus?: int32(name='JobStatus'),
    jobType?: int32(name='JobType'),
    jobTypeName?: string(name='JobTypeName'),
    mode?: int32(name='Mode'),
    modeName?: string(name='ModeName'),
    participantList?: [ 
      {
        participantId?: long(name='ParticipantId'),
        participantName?: string(name='ParticipantName'),
      }
    ](name='ParticipantList'),
    planList?: [ string ](name='PlanList'),
    projectId?: long(name='ProjectId'),
    projectName?: string(name='ProjectName'),
    protocolTypeList?: [ string ](name='ProtocolTypeList'),
    scheduleCron?: string(name='ScheduleCron'),
    scheduleType?: int32(name='ScheduleType'),
    scheduleTypeName?: string(name='ScheduleTypeName'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetMpcPrivateIdJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetMpcPrivateIdJobResponseBody(name='body'),
}

async function getMpcPrivateIdJobWithOptions(request: GetMpcPrivateIdJobRequest, runtime: Util.RuntimeOptions): GetMpcPrivateIdJobResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetMpcPrivateIdJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getMpcPrivateIdJob(request: GetMpcPrivateIdJobRequest): GetMpcPrivateIdJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return getMpcPrivateIdJobWithOptions(request, runtime);
}

model GetMpcSqlJobRequest {
  jobId?: long(name='JobId'),
}

model GetMpcSqlJobResponseBody = {
  code?: long(name='Code'),
  data?: {
    approvalId?: long(name='ApprovalId'),
    approvalStatus?: int32(name='ApprovalStatus'),
    configuration?: string(name='Configuration'),
    creatorId?: long(name='CreatorId'),
    dataSetDtos?: [ 
      {
        columns?: [ string ](name='Columns'),
        dataOwnerId?: long(name='DataOwnerId'),
        dataOwnerName?: string(name='DataOwnerName'),
        dataRole?: int32(name='DataRole'),
        dataSetId?: long(name='DataSetId'),
        dataSetName?: string(name='DataSetName'),
        dataSetUsage?: int32(name='DataSetUsage'),
        filterStr?: string(name='FilterStr'),
        flFeatureColumns?: [ 
          {
            columnDataType?: string(name='ColumnDataType'),
            columnDesc?: string(name='ColumnDesc'),
            columnName?: string(name='ColumnName'),
            isPartitionColumn?: boolean(name='IsPartitionColumn'),
          }
        ](name='FlFeatureColumns'),
        flLabelColumn?: string(name='FlLabelColumn'),
        inputColumns?: [ 
          {
            dataSetRole?: int32(name='DataSetRole'),
            dataType?: string(name='DataType'),
            inputColumnDesc?: string(name='InputColumnDesc'),
            inputColumnName?: string(name='InputColumnName'),
            outputColumnDesc?: string(name='OutputColumnDesc'),
            outputColumnName?: string(name='OutputColumnName'),
          }
        ](name='InputColumns'),
        inputDs?: string(name='InputDs'),
        order?: int32(name='Order'),
        outputColumns?: [ 
          {
            dataSetRole?: int32(name='DataSetRole'),
            dataType?: string(name='DataType'),
            inputColumnDesc?: string(name='InputColumnDesc'),
            inputColumnName?: string(name='InputColumnName'),
            outputColumnDesc?: string(name='OutputColumnDesc'),
            outputColumnName?: string(name='OutputColumnName'),
          }
        ](name='OutputColumns'),
        outputDataSetId?: long(name='OutputDataSetId'),
        outputDs?: string(name='OutputDs'),
        outputName?: string(name='OutputName'),
        preSql?: string(name='PreSql'),
      }
    ](name='DataSetDtos'),
    gmtCreate?: string(name='GmtCreate'),
    inputs?: [ string ](name='Inputs'),
    jobId?: long(name='JobId'),
    jobName?: string(name='JobName'),
    jobStatus?: int32(name='JobStatus'),
    jobType?: int32(name='JobType'),
    jobTypeName?: string(name='JobTypeName'),
    mode?: int32(name='Mode'),
    modeName?: string(name='ModeName'),
    outputs?: [ string ](name='Outputs'),
    planList?: [ string ](name='PlanList'),
    projectId?: long(name='ProjectId'),
    projectName?: string(name='ProjectName'),
    protocolTypeList?: [ string ](name='ProtocolTypeList'),
    scheduleCron?: string(name='ScheduleCron'),
    scheduleType?: int32(name='ScheduleType'),
    scheduleTypeName?: string(name='ScheduleTypeName'),
    sql?: string(name='Sql'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetMpcSqlJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetMpcSqlJobResponseBody(name='body'),
}

async function getMpcSqlJobWithOptions(request: GetMpcSqlJobRequest, runtime: Util.RuntimeOptions): GetMpcSqlJobResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetMpcSqlJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getMpcSqlJob(request: GetMpcSqlJobRequest): GetMpcSqlJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return getMpcSqlJobWithOptions(request, runtime);
}

model GetPrivateDataDetailRequest {
  projectId?: long(name='ProjectId'),
  tableId?: long(name='TableId'),
}

model GetPrivateDataDetailResponseBody = {
  code?: long(name='Code'),
  data?: {
    columnDtos?: [ 
      {
        col?: string(name='Col'),
        comment?: string(name='Comment'),
        dataSourceId?: long(name='DataSourceId'),
        dataType?: string(name='DataType'),
        id?: long(name='Id'),
        isPrimaryKey?: int32(name='IsPrimaryKey'),
        isPt?: int32(name='IsPt'),
        selected?: int32(name='Selected'),
        sn?: int32(name='Sn'),
        sqlType?: int32(name='SqlType'),
      }
    ](name='ColumnDtos'),
    isSync?: boolean(name='IsSync'),
    lastSyncUserId?: long(name='LastSyncUserId'),
    lastSyncUserName?: string(name='LastSyncUserName'),
    tableDto?: {
      comment?: string(name='Comment'),
      csccTableId?: long(name='CsccTableId'),
      dataSourceId?: long(name='DataSourceId'),
      dataSourceName?: string(name='DataSourceName'),
      dataSourceTypeId?: int32(name='DataSourceTypeId'),
      dataSourceTypeName?: string(name='DataSourceTypeName'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      lastSyncTime?: string(name='LastSyncTime'),
      lsccTableId?: long(name='LsccTableId'),
      name?: string(name='Name'),
      ossPath?: string(name='OssPath'),
      ownerId?: long(name='OwnerId'),
      ownerName?: string(name='OwnerName'),
      prj?: string(name='Prj'),
      scheduleType?: int32(name='ScheduleType'),
      schema?: string(name='Schema'),
      srcType?: int32(name='SrcType'),
      tab?: string(name='Tab'),
    }(name='TableDto'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetPrivateDataDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetPrivateDataDetailResponseBody(name='body'),
}

async function getPrivateDataDetailWithOptions(request: GetPrivateDataDetailRequest, runtime: Util.RuntimeOptions): GetPrivateDataDetailResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.tableId)) {
    body['TableId'] = request.tableId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetPrivateDataDetail',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getPrivateDataDetail(request: GetPrivateDataDetailRequest): GetPrivateDataDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return getPrivateDataDetailWithOptions(request, runtime);
}

model GetPrivateIdJobRequest {
  jobId?: long(name='JobId'),
}

model GetPrivateIdJobResponseBody = {
  code?: long(name='Code'),
  data?: {
    approvalId?: long(name='ApprovalId'),
    approvalStatus?: int32(name='ApprovalStatus'),
    configuration?: string(name='Configuration'),
    creatorId?: long(name='CreatorId'),
    dataSetDtos?: [ 
      {
        columns?: [ string ](name='Columns'),
        dataOwnerId?: long(name='DataOwnerId'),
        dataOwnerName?: string(name='DataOwnerName'),
        dataRole?: int32(name='DataRole'),
        dataSetId?: long(name='DataSetId'),
        dataSetName?: string(name='DataSetName'),
        dataSetUsage?: int32(name='DataSetUsage'),
        filterStr?: string(name='FilterStr'),
        flFeatureColumns?: [ 
          {
            columnDataType?: string(name='ColumnDataType'),
            columnDesc?: string(name='ColumnDesc'),
            columnName?: string(name='ColumnName'),
            isPartitionColumn?: boolean(name='IsPartitionColumn'),
          }
        ](name='FlFeatureColumns'),
        flLabelColumn?: string(name='FlLabelColumn'),
        inputColumns?: [ 
          {
            dataSetRole?: int32(name='DataSetRole'),
            dataType?: string(name='DataType'),
            inputColumnDesc?: string(name='InputColumnDesc'),
            inputColumnName?: string(name='InputColumnName'),
            outputColumnDesc?: string(name='OutputColumnDesc'),
            outputColumnName?: string(name='OutputColumnName'),
          }
        ](name='InputColumns'),
        inputDs?: string(name='InputDs'),
        order?: int32(name='Order'),
        outputColumns?: [ 
          {
            dataSetRole?: int32(name='DataSetRole'),
            dataType?: string(name='DataType'),
            inputColumnDesc?: string(name='InputColumnDesc'),
            inputColumnName?: string(name='InputColumnName'),
            outputColumnDesc?: string(name='OutputColumnDesc'),
            outputColumnName?: string(name='OutputColumnName'),
          }
        ](name='OutputColumns'),
        outputDataSetId?: long(name='OutputDataSetId'),
        outputDs?: string(name='OutputDs'),
        outputName?: string(name='OutputName'),
        preSql?: string(name='PreSql'),
      }
    ](name='DataSetDtos'),
    gmtCreate?: string(name='GmtCreate'),
    jobId?: long(name='JobId'),
    jobName?: string(name='JobName'),
    jobStatus?: int32(name='JobStatus'),
    jobType?: int32(name='JobType'),
    jobTypeName?: string(name='JobTypeName'),
    mode?: int32(name='Mode'),
    modeName?: string(name='ModeName'),
    participantList?: [ 
      {
        participantId?: long(name='ParticipantId'),
        participantName?: string(name='ParticipantName'),
      }
    ](name='ParticipantList'),
    planList?: [ string ](name='PlanList'),
    projectId?: long(name='ProjectId'),
    projectName?: string(name='ProjectName'),
    protocolTypeList?: [ string ](name='ProtocolTypeList'),
    scheduleCron?: string(name='ScheduleCron'),
    scheduleType?: int32(name='ScheduleType'),
    scheduleTypeName?: string(name='ScheduleTypeName'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetPrivateIdJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetPrivateIdJobResponseBody(name='body'),
}

async function getPrivateIdJobWithOptions(request: GetPrivateIdJobRequest, runtime: Util.RuntimeOptions): GetPrivateIdJobResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetPrivateIdJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getPrivateIdJob(request: GetPrivateIdJobRequest): GetPrivateIdJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return getPrivateIdJobWithOptions(request, runtime);
}

model GetProjectByTokenRequest {
  token?: string(name='Token'),
}

model GetProjectByTokenResponseBody = {
  code?: long(name='Code'),
  data?: {
    approvalId?: long(name='ApprovalId'),
    approvalState?: int32(name='ApprovalState'),
    approvalStateName?: string(name='ApprovalStateName'),
    approvalType?: int32(name='ApprovalType'),
    approvalTypeName?: string(name='ApprovalTypeName'),
    companyName?: string(name='CompanyName'),
    fullCompanyName?: string(name='FullCompanyName'),
    gmtCreate?: long(name='GmtCreate'),
    id?: long(name='Id'),
    jobId?: long(name='JobId'),
    jobName?: string(name='JobName'),
    projectId?: long(name='ProjectId'),
    projectName?: string(name='ProjectName'),
    proposerId?: long(name='ProposerId'),
    proposerName?: string(name='ProposerName'),
    serviceHost?: string(name='ServiceHost'),
    servicePort?: string(name='ServicePort'),
    snapShot?: string(name='SnapShot'),
    token?: string(name='Token'),
    transportHost?: string(name='TransportHost'),
    transportPort?: string(name='TransportPort'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetProjectByTokenResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetProjectByTokenResponseBody(name='body'),
}

async function getProjectByTokenWithOptions(request: GetProjectByTokenRequest, runtime: Util.RuntimeOptions): GetProjectByTokenResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.token)) {
    body['Token'] = request.token;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetProjectByToken',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getProjectByToken(request: GetProjectByTokenRequest): GetProjectByTokenResponse {
  var runtime = new Util.RuntimeOptions{};
  return getProjectByTokenWithOptions(request, runtime);
}

model GetProjectDetailRequest {
  projectId?: long(name='ProjectId'),
  projectType?: int32(name='ProjectType'),
}

model GetProjectDetailResponseBody = {
  code?: long(name='Code'),
  data?: {
    config?: string(name='Config'),
    csccProjectId?: long(name='CsccProjectId'),
    dataSourceId?: string(name='DataSourceId'),
    description?: string(name='Description'),
    gmtCreate?: string(name='GmtCreate'),
    gmtModified?: string(name='GmtModified'),
    host?: string(name='Host'),
    id?: long(name='Id'),
    members?: [ 
      {
        account?: string(name='Account'),
        gmtModified?: string(name='GmtModified'),
        memberId?: long(name='MemberId'),
        memberName?: string(name='MemberName'),
        role?: int32(name='Role'),
        userId?: string(name='UserId'),
      }
    ](name='Members'),
    name?: string(name='Name'),
    ownerId?: long(name='OwnerId'),
    ownerName?: string(name='OwnerName'),
    ownerUserId?: string(name='OwnerUserId'),
    port?: string(name='Port'),
    projectModeList?: [ int32 ](name='ProjectModeList'),
    projectStatus?: int32(name='ProjectStatus'),
    transportHost?: string(name='TransportHost'),
    transportPort?: string(name='TransportPort'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetProjectDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetProjectDetailResponseBody(name='body'),
}

async function getProjectDetailWithOptions(request: GetProjectDetailRequest, runtime: Util.RuntimeOptions): GetProjectDetailResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectType)) {
    body['ProjectType'] = request.projectType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetProjectDetail',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getProjectDetail(request: GetProjectDetailRequest): GetProjectDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return getProjectDetailWithOptions(request, runtime);
}

model GetProjectSettingRequest {
  projectId?: long(name='ProjectId'),
}

model GetProjectSettingResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      jobName?: string(name='JobName'),
      jobType?: int32(name='JobType'),
      modeName?: string(name='ModeName'),
      modeType?: int32(name='ModeType'),
      selected?: boolean(name='Selected'),
      visible?: boolean(name='Visible'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetProjectSettingResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetProjectSettingResponseBody(name='body'),
}

async function getProjectSettingWithOptions(request: GetProjectSettingRequest, runtime: Util.RuntimeOptions): GetProjectSettingResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetProjectSetting',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getProjectSetting(request: GetProjectSettingRequest): GetProjectSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return getProjectSettingWithOptions(request, runtime);
}

model GetProjectStatsResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      failedCount?: int32(name='FailedCount'),
      processCount?: int32(name='ProcessCount'),
      projectId?: long(name='ProjectId'),
      projectName?: string(name='ProjectName'),
      secCount?: int32(name='SecCount'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetProjectStatsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetProjectStatsResponseBody(name='body'),
}

async function getProjectStatsWithOptions(runtime: Util.RuntimeOptions): GetProjectStatsResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'GetProjectStats',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getProjectStats(): GetProjectStatsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getProjectStatsWithOptions(runtime);
}

model GetStepForwardLogRequest {
  end?: long(name='End'),
  instanceId?: long(name='InstanceId'),
  role?: int32(name='Role'),
  start?: long(name='Start'),
  step?: int32(name='Step'),
}

model GetStepForwardLogResponseBody = {
  code?: long(name='Code'),
  data?: {
    forwardLogs?: [ 
      {
        instanceId?: string(name='InstanceId'),
        message?: string(name='Message'),
        sdfJobId?: string(name='SdfJobId'),
        ssJobId?: string(name='SsJobId'),
        ssTaskName?: string(name='SsTaskName'),
        ssTaskStep?: string(name='SsTaskStep'),
        ssTaskType?: string(name='SsTaskType'),
        timestamp?: long(name='Timestamp'),
      }
    ](name='ForwardLogs'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetStepForwardLogResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetStepForwardLogResponseBody(name='body'),
}

async function getStepForwardLogWithOptions(request: GetStepForwardLogRequest, runtime: Util.RuntimeOptions): GetStepForwardLogResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.end)) {
    body['End'] = request.end;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.role)) {
    body['Role'] = request.role;
  }
  if (!Util.isUnset(request.start)) {
    body['Start'] = request.start;
  }
  if (!Util.isUnset(request.step)) {
    body['Step'] = request.step;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetStepForwardLog',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getStepForwardLog(request: GetStepForwardLogRequest): GetStepForwardLogResponse {
  var runtime = new Util.RuntimeOptions{};
  return getStepForwardLogWithOptions(request, runtime);
}

model GetTableIdByNameRequest {
  tableName?: string(name='TableName'),
}

model GetTableIdByNameResponseBody = {
  code?: long(name='Code'),
  data?: long(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetTableIdByNameResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetTableIdByNameResponseBody(name='body'),
}

async function getTableIdByNameWithOptions(request: GetTableIdByNameRequest, runtime: Util.RuntimeOptions): GetTableIdByNameResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.tableName)) {
    body['TableName'] = request.tableName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetTableIdByName',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTableIdByName(request: GetTableIdByNameRequest): GetTableIdByNameResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTableIdByNameWithOptions(request, runtime);
}

model GetTrustDaPsiJobRequest {
  jobId?: long(name='JobId'),
}

model GetTrustDaPsiJobResponseBody = {
  code?: long(name='Code'),
  data?: {
    approvalId?: long(name='ApprovalId'),
    approvalStatus?: int32(name='ApprovalStatus'),
    configuration?: string(name='Configuration'),
    creatorId?: long(name='CreatorId'),
    dataSetDtos?: [ 
      {
        columns?: [ string ](name='Columns'),
        dataOwnerId?: long(name='DataOwnerId'),
        dataOwnerName?: string(name='DataOwnerName'),
        dataRole?: int32(name='DataRole'),
        dataSetId?: long(name='DataSetId'),
        dataSetName?: string(name='DataSetName'),
        dataSetUsage?: int32(name='DataSetUsage'),
        filterStr?: string(name='FilterStr'),
        flFeatureColumns?: [ 
          {
            columnDataType?: string(name='ColumnDataType'),
            columnDesc?: string(name='ColumnDesc'),
            columnName?: string(name='ColumnName'),
            isPartitionColumn?: boolean(name='IsPartitionColumn'),
          }
        ](name='FlFeatureColumns'),
        flLabelColumn?: string(name='FlLabelColumn'),
        inputColumns?: [ 
          {
            dataSetRole?: int32(name='DataSetRole'),
            dataType?: string(name='DataType'),
            inputColumnDesc?: string(name='InputColumnDesc'),
            inputColumnName?: string(name='InputColumnName'),
            outputColumnDesc?: string(name='OutputColumnDesc'),
            outputColumnName?: string(name='OutputColumnName'),
          }
        ](name='InputColumns'),
        inputDs?: string(name='InputDs'),
        order?: int32(name='Order'),
        outputColumns?: [ 
          {
            dataSetRole?: int32(name='DataSetRole'),
            dataType?: string(name='DataType'),
            inputColumnDesc?: string(name='InputColumnDesc'),
            inputColumnName?: string(name='InputColumnName'),
            outputColumnDesc?: string(name='OutputColumnDesc'),
            outputColumnName?: string(name='OutputColumnName'),
          }
        ](name='OutputColumns'),
        outputDataSetId?: long(name='OutputDataSetId'),
        outputDs?: string(name='OutputDs'),
        outputName?: string(name='OutputName'),
        preSql?: string(name='PreSql'),
      }
    ](name='DataSetDtos'),
    gmtCreate?: string(name='GmtCreate'),
    jobId?: long(name='JobId'),
    jobName?: string(name='JobName'),
    jobStatus?: int32(name='JobStatus'),
    jobType?: int32(name='JobType'),
    jobTypeName?: string(name='JobTypeName'),
    mode?: int32(name='Mode'),
    modeName?: string(name='ModeName'),
    planList?: [ string ](name='PlanList'),
    projectId?: long(name='ProjectId'),
    projectName?: string(name='ProjectName'),
    protocolTypeList?: [ string ](name='ProtocolTypeList'),
    psiPreCacheConfig?: {
      cacheUsage?: long(name='CacheUsage'),
      isUsePsiPreCache?: boolean(name='IsUsePsiPreCache'),
      localBasePath?: string(name='LocalBasePath'),
      psiPreCacheColumn?: [ string ](name='PsiPreCacheColumn'),
      psiPreCacheDataName?: string(name='PsiPreCacheDataName'),
      psiPreCacheJobId?: long(name='PsiPreCacheJobId'),
      psiPreCacheJobName?: string(name='PsiPreCacheJobName'),
    }(name='PsiPreCacheConfig'),
    scheduleCron?: string(name='ScheduleCron'),
    scheduleType?: int32(name='ScheduleType'),
    scheduleTypeName?: string(name='ScheduleTypeName'),
    sql?: string(name='Sql'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetTrustDaPsiJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetTrustDaPsiJobResponseBody(name='body'),
}

async function getTrustDaPsiJobWithOptions(request: GetTrustDaPsiJobRequest, runtime: Util.RuntimeOptions): GetTrustDaPsiJobResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetTrustDaPsiJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTrustDaPsiJob(request: GetTrustDaPsiJobRequest): GetTrustDaPsiJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTrustDaPsiJobWithOptions(request, runtime);
}

model GetTrustDaPsiPreCacheJobRequest {
  jobId?: long(name='JobId'),
}

model GetTrustDaPsiPreCacheJobResponseBody = {
  code?: long(name='Code'),
  data?: {
    approvalId?: long(name='ApprovalId'),
    approvalStatus?: int32(name='ApprovalStatus'),
    configuration?: string(name='Configuration'),
    creatorId?: long(name='CreatorId'),
    dataSetDtos?: [ 
      {
        columns?: [ string ](name='Columns'),
        dataOwnerId?: long(name='DataOwnerId'),
        dataOwnerName?: string(name='DataOwnerName'),
        dataRole?: int32(name='DataRole'),
        dataSetId?: long(name='DataSetId'),
        dataSetName?: string(name='DataSetName'),
        dataSetUsage?: int32(name='DataSetUsage'),
        filterStr?: string(name='FilterStr'),
        flFeatureColumns?: [ 
          {
            columnDataType?: string(name='ColumnDataType'),
            columnDesc?: string(name='ColumnDesc'),
            columnName?: string(name='ColumnName'),
            isPartitionColumn?: boolean(name='IsPartitionColumn'),
          }
        ](name='FlFeatureColumns'),
        flLabelColumn?: string(name='FlLabelColumn'),
        inputColumns?: [ 
          {
            dataSetRole?: int32(name='DataSetRole'),
            dataType?: string(name='DataType'),
            inputColumnDesc?: string(name='InputColumnDesc'),
            inputColumnName?: string(name='InputColumnName'),
            outputColumnDesc?: string(name='OutputColumnDesc'),
            outputColumnName?: string(name='OutputColumnName'),
          }
        ](name='InputColumns'),
        inputDs?: string(name='InputDs'),
        order?: int32(name='Order'),
        outputColumns?: [ 
          {
            dataSetRole?: int32(name='DataSetRole'),
            dataType?: string(name='DataType'),
            inputColumnDesc?: string(name='InputColumnDesc'),
            inputColumnName?: string(name='InputColumnName'),
            outputColumnDesc?: string(name='OutputColumnDesc'),
            outputColumnName?: string(name='OutputColumnName'),
          }
        ](name='OutputColumns'),
        outputDataSetId?: long(name='OutputDataSetId'),
        outputDs?: string(name='OutputDs'),
        outputName?: string(name='OutputName'),
        preSql?: string(name='PreSql'),
      }
    ](name='DataSetDtos'),
    gmtCreate?: string(name='GmtCreate'),
    jobId?: long(name='JobId'),
    jobName?: string(name='JobName'),
    jobStatus?: int32(name='JobStatus'),
    jobType?: int32(name='JobType'),
    jobTypeName?: string(name='JobTypeName'),
    mode?: int32(name='Mode'),
    modeName?: string(name='ModeName'),
    planList?: [ string ](name='PlanList'),
    projectId?: long(name='ProjectId'),
    projectName?: string(name='ProjectName'),
    protocolTypeList?: [ string ](name='ProtocolTypeList'),
    psiPreCacheConfig?: {
      cacheUsage?: long(name='CacheUsage'),
      isUsePsiPreCache?: boolean(name='IsUsePsiPreCache'),
      localBasePath?: string(name='LocalBasePath'),
      psiPreCacheColumn?: [ string ](name='PsiPreCacheColumn'),
      psiPreCacheDataName?: string(name='PsiPreCacheDataName'),
      psiPreCacheJobId?: long(name='PsiPreCacheJobId'),
      psiPreCacheJobName?: string(name='PsiPreCacheJobName'),
    }(name='PsiPreCacheConfig'),
    scheduleCron?: string(name='ScheduleCron'),
    scheduleType?: int32(name='ScheduleType'),
    scheduleTypeName?: string(name='ScheduleTypeName'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetTrustDaPsiPreCacheJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetTrustDaPsiPreCacheJobResponseBody(name='body'),
}

async function getTrustDaPsiPreCacheJobWithOptions(request: GetTrustDaPsiPreCacheJobRequest, runtime: Util.RuntimeOptions): GetTrustDaPsiPreCacheJobResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetTrustDaPsiPreCacheJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTrustDaPsiPreCacheJob(request: GetTrustDaPsiPreCacheJobRequest): GetTrustDaPsiPreCacheJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTrustDaPsiPreCacheJobWithOptions(request, runtime);
}

model GetTrustDaSqlJobRequest {
  jobId?: long(name='JobId'),
}

model GetTrustDaSqlJobResponseBody = {
  code?: long(name='Code'),
  data?: {
    approvalId?: long(name='ApprovalId'),
    approvalStatus?: int32(name='ApprovalStatus'),
    configuration?: string(name='Configuration'),
    creatorId?: long(name='CreatorId'),
    dataSetDtos?: [ 
      {
        columns?: [ string ](name='Columns'),
        dataOwnerId?: long(name='DataOwnerId'),
        dataOwnerName?: string(name='DataOwnerName'),
        dataRole?: int32(name='DataRole'),
        dataSetId?: long(name='DataSetId'),
        dataSetName?: string(name='DataSetName'),
        dataSetUsage?: int32(name='DataSetUsage'),
        filterStr?: string(name='FilterStr'),
        flFeatureColumns?: [ 
          {
            columnDataType?: string(name='ColumnDataType'),
            columnDesc?: string(name='ColumnDesc'),
            columnName?: string(name='ColumnName'),
            isPartitionColumn?: boolean(name='IsPartitionColumn'),
          }
        ](name='FlFeatureColumns'),
        flLabelColumn?: string(name='FlLabelColumn'),
        inputColumns?: [ 
          {
            dataSetRole?: int32(name='DataSetRole'),
            dataType?: string(name='DataType'),
            inputColumnDesc?: string(name='InputColumnDesc'),
            inputColumnName?: string(name='InputColumnName'),
            outputColumnDesc?: string(name='OutputColumnDesc'),
            outputColumnName?: string(name='OutputColumnName'),
          }
        ](name='InputColumns'),
        inputDs?: string(name='InputDs'),
        order?: int32(name='Order'),
        outputColumns?: [ 
          {
            dataSetRole?: int32(name='DataSetRole'),
            dataType?: string(name='DataType'),
            inputColumnDesc?: string(name='InputColumnDesc'),
            inputColumnName?: string(name='InputColumnName'),
            outputColumnDesc?: string(name='OutputColumnDesc'),
            outputColumnName?: string(name='OutputColumnName'),
          }
        ](name='OutputColumns'),
        outputDataSetId?: long(name='OutputDataSetId'),
        outputDs?: string(name='OutputDs'),
        outputName?: string(name='OutputName'),
        preSql?: string(name='PreSql'),
      }
    ](name='DataSetDtos'),
    gmtCreate?: string(name='GmtCreate'),
    inputs?: [ string ](name='Inputs'),
    jobId?: long(name='JobId'),
    jobName?: string(name='JobName'),
    jobStatus?: int32(name='JobStatus'),
    jobType?: int32(name='JobType'),
    jobTypeName?: string(name='JobTypeName'),
    mode?: int32(name='Mode'),
    modeName?: string(name='ModeName'),
    outputs?: [ string ](name='Outputs'),
    planList?: [ string ](name='PlanList'),
    projectId?: long(name='ProjectId'),
    projectName?: string(name='ProjectName'),
    protocolTypeList?: [ string ](name='ProtocolTypeList'),
    scheduleCron?: string(name='ScheduleCron'),
    scheduleType?: int32(name='ScheduleType'),
    scheduleTypeName?: string(name='ScheduleTypeName'),
    sql?: string(name='Sql'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetTrustDaSqlJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetTrustDaSqlJobResponseBody(name='body'),
}

async function getTrustDaSqlJobWithOptions(request: GetTrustDaSqlJobRequest, runtime: Util.RuntimeOptions): GetTrustDaSqlJobResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetTrustDaSqlJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTrustDaSqlJob(request: GetTrustDaSqlJobRequest): GetTrustDaSqlJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTrustDaSqlJobWithOptions(request, runtime);
}

model GetTrustMlPredictionDataProcessConfigRequest {
  algName?: string(name='AlgName'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  featureFormat?: int32(name='FeatureFormat'),
  jobId?: long(name='JobId'),
  jobType?: int32(name='JobType'),
  projectId?: long(name='ProjectId'),
  trainingJobId?: long(name='TrainingJobId'),
}

model GetTrustMlPredictionDataProcessConfigResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      binningCount?: int32(name='BinningCount'),
      binningInterval?: string(name='BinningInterval'),
      binningType?: int32(name='BinningType'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      field?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='Field'),
      processType?: int32(name='ProcessType'),
      processedValue?: string(name='ProcessedValue'),
      rawValues?: [ string ](name='RawValues'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetTrustMlPredictionDataProcessConfigResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetTrustMlPredictionDataProcessConfigResponseBody(name='body'),
}

async function getTrustMlPredictionDataProcessConfigWithOptions(request: GetTrustMlPredictionDataProcessConfigRequest, runtime: Util.RuntimeOptions): GetTrustMlPredictionDataProcessConfigResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.algName)) {
    body['AlgName'] = request.algName;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.featureFormat)) {
    body['FeatureFormat'] = request.featureFormat;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.trainingJobId)) {
    body['TrainingJobId'] = request.trainingJobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetTrustMlPredictionDataProcessConfig',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTrustMlPredictionDataProcessConfig(request: GetTrustMlPredictionDataProcessConfigRequest): GetTrustMlPredictionDataProcessConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTrustMlPredictionDataProcessConfigWithOptions(request, runtime);
}

model GetTrustMlPredictionJobRequest {
  jobId?: long(name='JobId'),
}

model GetTrustMlPredictionJobResponseBody = {
  code?: long(name='Code'),
  data?: {
    approvalId?: long(name='ApprovalId'),
    approvalStatus?: int32(name='ApprovalStatus'),
    configuration?: string(name='Configuration'),
    creatorId?: long(name='CreatorId'),
    dataProcessDtoList?: [ 
      {
        binningCount?: int32(name='BinningCount'),
        binningInterval?: string(name='BinningInterval'),
        binningType?: int32(name='BinningType'),
        dataOwnerId?: long(name='DataOwnerId'),
        dataOwnerName?: string(name='DataOwnerName'),
        dataSetId?: long(name='DataSetId'),
        dataSetName?: string(name='DataSetName'),
        dataSetUsage?: int32(name='DataSetUsage'),
        field?: [ 
          {
            columnDataType?: string(name='ColumnDataType'),
            columnDesc?: string(name='ColumnDesc'),
            columnName?: string(name='ColumnName'),
            isPartitionColumn?: boolean(name='IsPartitionColumn'),
          }
        ](name='Field'),
        processType?: int32(name='ProcessType'),
        processedValue?: string(name='ProcessedValue'),
        rawValues?: [ string ](name='RawValues'),
      }
    ](name='DataProcessDtoList'),
    dataProcessTypeOrder?: [ int32 ](name='DataProcessTypeOrder'),
    dataSetDtos?: [ 
      {
        columns?: [ string ](name='Columns'),
        dataOwnerId?: long(name='DataOwnerId'),
        dataOwnerName?: string(name='DataOwnerName'),
        dataRole?: int32(name='DataRole'),
        dataSetId?: long(name='DataSetId'),
        dataSetName?: string(name='DataSetName'),
        dataSetUsage?: int32(name='DataSetUsage'),
        filterStr?: string(name='FilterStr'),
        flFeatureColumns?: [ 
          {
            columnDataType?: string(name='ColumnDataType'),
            columnDesc?: string(name='ColumnDesc'),
            columnName?: string(name='ColumnName'),
            isPartitionColumn?: boolean(name='IsPartitionColumn'),
          }
        ](name='FlFeatureColumns'),
        flLabelColumn?: string(name='FlLabelColumn'),
        inputColumns?: [ 
          {
            dataSetRole?: int32(name='DataSetRole'),
            dataType?: string(name='DataType'),
            inputColumnDesc?: string(name='InputColumnDesc'),
            inputColumnName?: string(name='InputColumnName'),
            outputColumnDesc?: string(name='OutputColumnDesc'),
            outputColumnName?: string(name='OutputColumnName'),
          }
        ](name='InputColumns'),
        inputDs?: string(name='InputDs'),
        order?: int32(name='Order'),
        outputColumns?: [ 
          {
            dataSetRole?: int32(name='DataSetRole'),
            dataType?: string(name='DataType'),
            inputColumnDesc?: string(name='InputColumnDesc'),
            inputColumnName?: string(name='InputColumnName'),
            outputColumnDesc?: string(name='OutputColumnDesc'),
            outputColumnName?: string(name='OutputColumnName'),
          }
        ](name='OutputColumns'),
        outputDataSetId?: long(name='OutputDataSetId'),
        outputDs?: string(name='OutputDs'),
        outputName?: string(name='OutputName'),
        preSql?: string(name='PreSql'),
      }
    ](name='DataSetDtos'),
    featureDistribution?: int32(name='FeatureDistribution'),
    featureFormat?: int32(name='FeatureFormat'),
    gmtCreate?: string(name='GmtCreate'),
    hostFeatureNum?: int32(name='HostFeatureNum'),
    jobId?: long(name='JobId'),
    jobName?: string(name='JobName'),
    jobStatus?: int32(name='JobStatus'),
    jobType?: int32(name='JobType'),
    jobTypeName?: string(name='JobTypeName'),
    mode?: int32(name='Mode'),
    modeName?: string(name='ModeName'),
    outputDs?: string(name='OutputDs'),
    outputId?: long(name='OutputId'),
    outputName?: string(name='OutputName'),
    partitionType?: int32(name='PartitionType'),
    planList?: [ string ](name='PlanList'),
    predictionResultTo?: int32(name='PredictionResultTo'),
    projectId?: long(name='ProjectId'),
    projectName?: string(name='ProjectName'),
    protocolTypeList?: [ string ](name='ProtocolTypeList'),
    scheduleCron?: string(name='ScheduleCron'),
    scheduleType?: int32(name='ScheduleType'),
    scheduleTypeName?: string(name='ScheduleTypeName'),
    serviceApiId?: string(name='ServiceApiId'),
    slaveFeatureNum?: int32(name='SlaveFeatureNum'),
    trainingJobId?: long(name='TrainingJobId'),
    trainingJobName?: string(name='TrainingJobName'),
    trainingModelId?: long(name='TrainingModelId'),
    trainingModelName?: string(name='TrainingModelName'),
    trainingModelVersion?: string(name='TrainingModelVersion'),
    trainingModelVersionName?: string(name='TrainingModelVersionName'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetTrustMlPredictionJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetTrustMlPredictionJobResponseBody(name='body'),
}

async function getTrustMlPredictionJobWithOptions(request: GetTrustMlPredictionJobRequest, runtime: Util.RuntimeOptions): GetTrustMlPredictionJobResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetTrustMlPredictionJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTrustMlPredictionJob(request: GetTrustMlPredictionJobRequest): GetTrustMlPredictionJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTrustMlPredictionJobWithOptions(request, runtime);
}

model GetTrustMlTrainingJobRequest {
  jobId?: long(name='JobId'),
}

model GetTrustMlTrainingJobResponseBody = {
  code?: long(name='Code'),
  data?: {
    algId?: long(name='AlgId'),
    algName?: string(name='AlgName'),
    algRound?: int32(name='AlgRound'),
    algTypeId?: long(name='AlgTypeId'),
    algTypeName?: string(name='AlgTypeName'),
    algVersion?: string(name='AlgVersion'),
    approvalId?: long(name='ApprovalId'),
    approvalStatus?: int32(name='ApprovalStatus'),
    configuration?: string(name='Configuration'),
    creatorId?: long(name='CreatorId'),
    dataProcessDtoList?: [ 
      {
        binningCount?: int32(name='BinningCount'),
        binningInterval?: string(name='BinningInterval'),
        binningType?: int32(name='BinningType'),
        dataOwnerId?: long(name='DataOwnerId'),
        dataOwnerName?: string(name='DataOwnerName'),
        dataSetId?: long(name='DataSetId'),
        dataSetName?: string(name='DataSetName'),
        dataSetUsage?: int32(name='DataSetUsage'),
        field?: [ 
          {
            columnDataType?: string(name='ColumnDataType'),
            columnDesc?: string(name='ColumnDesc'),
            columnName?: string(name='ColumnName'),
            isPartitionColumn?: boolean(name='IsPartitionColumn'),
          }
        ](name='Field'),
        processType?: int32(name='ProcessType'),
        processedValue?: string(name='ProcessedValue'),
        rawValues?: [ string ](name='RawValues'),
      }
    ](name='DataProcessDtoList'),
    dataProcessTypeOrder?: [ int32 ](name='DataProcessTypeOrder'),
    dataSetDtos?: [ 
      {
        columns?: [ string ](name='Columns'),
        dataOwnerId?: long(name='DataOwnerId'),
        dataOwnerName?: string(name='DataOwnerName'),
        dataRole?: int32(name='DataRole'),
        dataSetId?: long(name='DataSetId'),
        dataSetName?: string(name='DataSetName'),
        dataSetUsage?: int32(name='DataSetUsage'),
        filterStr?: string(name='FilterStr'),
        flFeatureColumns?: [ 
          {
            columnDataType?: string(name='ColumnDataType'),
            columnDesc?: string(name='ColumnDesc'),
            columnName?: string(name='ColumnName'),
            isPartitionColumn?: boolean(name='IsPartitionColumn'),
          }
        ](name='FlFeatureColumns'),
        flLabelColumn?: string(name='FlLabelColumn'),
        inputColumns?: [ 
          {
            dataSetRole?: int32(name='DataSetRole'),
            dataType?: string(name='DataType'),
            inputColumnDesc?: string(name='InputColumnDesc'),
            inputColumnName?: string(name='InputColumnName'),
            outputColumnDesc?: string(name='OutputColumnDesc'),
            outputColumnName?: string(name='OutputColumnName'),
          }
        ](name='InputColumns'),
        inputDs?: string(name='InputDs'),
        order?: int32(name='Order'),
        outputColumns?: [ 
          {
            dataSetRole?: int32(name='DataSetRole'),
            dataType?: string(name='DataType'),
            inputColumnDesc?: string(name='InputColumnDesc'),
            inputColumnName?: string(name='InputColumnName'),
            outputColumnDesc?: string(name='OutputColumnDesc'),
            outputColumnName?: string(name='OutputColumnName'),
          }
        ](name='OutputColumns'),
        outputDataSetId?: long(name='OutputDataSetId'),
        outputDs?: string(name='OutputDs'),
        outputName?: string(name='OutputName'),
        preSql?: string(name='PreSql'),
      }
    ](name='DataSetDtos'),
    dynamicParams?: [ 
      {
        checker?: string(name='Checker'),
        displayMode?: string(name='DisplayMode'),
        inputMode?: string(name='InputMode'),
        paramName?: string(name='ParamName'),
        paramNameForDisplay?: string(name='ParamNameForDisplay'),
        paramValue?: string(name='ParamValue'),
      }
    ](name='DynamicParams'),
    featureDistribution?: int32(name='FeatureDistribution'),
    featureFormat?: int32(name='FeatureFormat'),
    gmtCreate?: string(name='GmtCreate'),
    hostFeatureNum?: int32(name='HostFeatureNum'),
    jobId?: long(name='JobId'),
    jobName?: string(name='JobName'),
    jobStatus?: int32(name='JobStatus'),
    jobType?: int32(name='JobType'),
    jobTypeName?: string(name='JobTypeName'),
    mode?: int32(name='Mode'),
    modeName?: string(name='ModeName'),
    partitionType?: int32(name='PartitionType'),
    planList?: [ string ](name='PlanList'),
    projectId?: long(name='ProjectId'),
    projectName?: string(name='ProjectName'),
    protocolTypeList?: [ string ](name='ProtocolTypeList'),
    randomSeed?: int32(name='RandomSeed'),
    scheduleCron?: string(name='ScheduleCron'),
    scheduleType?: int32(name='ScheduleType'),
    scheduleTypeName?: string(name='ScheduleTypeName'),
    slaveFeatureNum?: int32(name='SlaveFeatureNum'),
    trainingModelId?: long(name='TrainingModelId'),
    trainingModelName?: string(name='TrainingModelName'),
    trainingModelVersion?: [ string ](name='TrainingModelVersion'),
    trainingModelVersionName?: [ string ](name='TrainingModelVersionName'),
    trainingSetProportion?: int32(name='TrainingSetProportion'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetTrustMlTrainingJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetTrustMlTrainingJobResponseBody(name='body'),
}

async function getTrustMlTrainingJobWithOptions(request: GetTrustMlTrainingJobRequest, runtime: Util.RuntimeOptions): GetTrustMlTrainingJobResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetTrustMlTrainingJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTrustMlTrainingJob(request: GetTrustMlTrainingJobRequest): GetTrustMlTrainingJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTrustMlTrainingJobWithOptions(request, runtime);
}

model GetUserDetailRequest {
  userId?: string(name='UserId'),
}

model GetUserDetailResponseBody = {
  code?: long(name='Code'),
  data?: {
    bid?: int32(name='Bid'),
    csccMode?: string(name='CsccMode'),
    description?: string(name='Description'),
    id?: long(name='Id'),
    memberStatus?: int32(name='MemberStatus'),
    name?: string(name='Name'),
    sdfMemberExtInfo?: {
      aliyunAccount?: string(name='AliyunAccount'),
      aliyunNick?: string(name='AliyunNick'),
      extend?: string(name='Extend'),
      memberId?: long(name='MemberId'),
      projectId?: long(name='ProjectId'),
      uid?: string(name='Uid'),
    }(name='SdfMemberExtInfo'),
    sdfServiceDetail?: [ 
      {
        config?: string(name='Config'),
        memberId?: long(name='MemberId'),
        protocol?: string(name='Protocol'),
        type?: int32(name='Type'),
      }
    ](name='SdfServiceDetail'),
    uri?: string(name='Uri'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetUserDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetUserDetailResponseBody(name='body'),
}

async function getUserDetailWithOptions(request: GetUserDetailRequest, runtime: Util.RuntimeOptions): GetUserDetailResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.userId)) {
    body['UserId'] = request.userId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetUserDetail',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getUserDetail(request: GetUserDetailRequest): GetUserDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return getUserDetailWithOptions(request, runtime);
}

model InviteProjectMemberRequest {
  projectId?: long(name='ProjectId'),
}

model InviteProjectMemberResponseBody = {
  code?: long(name='Code'),
  data?: {
    expireTime?: string(name='ExpireTime'),
    host?: string(name='Host'),
    port?: string(name='Port'),
    projectName?: string(name='ProjectName'),
    token?: string(name='Token'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model InviteProjectMemberResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: InviteProjectMemberResponseBody(name='body'),
}

async function inviteProjectMemberWithOptions(request: InviteProjectMemberRequest, runtime: Util.RuntimeOptions): InviteProjectMemberResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'InviteProjectMember',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function inviteProjectMember(request: InviteProjectMemberRequest): InviteProjectMemberResponse {
  var runtime = new Util.RuntimeOptions{};
  return inviteProjectMemberWithOptions(request, runtime);
}

model JoinProjectRequest {
  host?: string(name='Host'),
  port?: string(name='Port'),
  token?: string(name='Token'),
}

model JoinProjectResponseBody = {
  code?: long(name='Code'),
  data?: {
    approvalId?: long(name='ApprovalId'),
    approvalState?: int32(name='ApprovalState'),
    approvalStateName?: string(name='ApprovalStateName'),
    approvalType?: int32(name='ApprovalType'),
    approvalTypeName?: string(name='ApprovalTypeName'),
    companyName?: string(name='CompanyName'),
    fullCompanyName?: string(name='FullCompanyName'),
    gmtCreate?: long(name='GmtCreate'),
    id?: long(name='Id'),
    jobId?: long(name='JobId'),
    jobName?: string(name='JobName'),
    projectId?: long(name='ProjectId'),
    projectName?: string(name='ProjectName'),
    proposerId?: long(name='ProposerId'),
    proposerName?: string(name='ProposerName'),
    serviceHost?: string(name='ServiceHost'),
    servicePort?: string(name='ServicePort'),
    snapShot?: string(name='SnapShot'),
    token?: string(name='Token'),
    transportHost?: string(name='TransportHost'),
    transportPort?: string(name='TransportPort'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model JoinProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: JoinProjectResponseBody(name='body'),
}

async function joinProjectWithOptions(request: JoinProjectRequest, runtime: Util.RuntimeOptions): JoinProjectResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.host)) {
    body['Host'] = request.host;
  }
  if (!Util.isUnset(request.port)) {
    body['Port'] = request.port;
  }
  if (!Util.isUnset(request.token)) {
    body['Token'] = request.token;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'JoinProject',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function joinProject(request: JoinProjectRequest): JoinProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return joinProjectWithOptions(request, runtime);
}

model ListCsccAlgModelingsRequest {
  mode?: int32(name='Mode'),
  modelingClassificationId?: long(name='ModelingClassificationId'),
}

model ListCsccAlgModelingsResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      args?: string(name='Args'),
      classificationId?: long(name='ClassificationId'),
      classificationName?: string(name='ClassificationName'),
      description?: string(name='Description'),
      gmtModified?: string(name='GmtModified'),
      imageId?: string(name='ImageId'),
      modelingId?: long(name='ModelingId'),
      modelingName?: string(name='ModelingName'),
      modelingType?: int32(name='ModelingType'),
      modelingVersion?: string(name='ModelingVersion'),
      paramDefinition?: string(name='ParamDefinition'),
      paramDefinitionDetails?: [ 
        {
          candidates?: [ string ](name='Candidates'),
          checker?: {
            format?: string(name='Format'),
            type?: string(name='Type'),
          }(name='Checker'),
          defaultValue?: string(name='DefaultValue'),
          displayMode?: string(name='DisplayMode'),
          inputMode?: string(name='InputMode'),
          paramDescription?: string(name='ParamDescription'),
          paramName?: string(name='ParamName'),
          paramNameForDisplay?: string(name='ParamNameForDisplay'),
        }
      ](name='ParamDefinitionDetails'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListCsccAlgModelingsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListCsccAlgModelingsResponseBody(name='body'),
}

async function listCsccAlgModelingsWithOptions(request: ListCsccAlgModelingsRequest, runtime: Util.RuntimeOptions): ListCsccAlgModelingsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modelingClassificationId)) {
    body['ModelingClassificationId'] = request.modelingClassificationId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListCsccAlgModelings',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listCsccAlgModelings(request: ListCsccAlgModelingsRequest): ListCsccAlgModelingsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCsccAlgModelingsWithOptions(request, runtime);
}

model ListCsccApprovalsRequest {
  approvalIds?: [ long ](name='ApprovalIds'),
  approvalStates?: [ int32 ](name='ApprovalStates'),
  approvalTypes?: [ int32 ](name='ApprovalTypes'),
  approverId?: long(name='ApproverId'),
  currentPage?: int32(name='CurrentPage'),
  jobName?: string(name='JobName'),
  order?: string(name='Order'),
  orderBy?: string(name='OrderBy'),
  pageSize?: int32(name='PageSize'),
  param?: map[string]any(name='Param'),
  projectId?: long(name='ProjectId'),
  proposerId?: long(name='ProposerId'),
  start?: int32(name='Start'),
  userId?: string(name='UserId'),
}

model ListCsccApprovalsShrinkRequest {
  approvalIdsShrink?: string(name='ApprovalIds'),
  approvalStatesShrink?: string(name='ApprovalStates'),
  approvalTypesShrink?: string(name='ApprovalTypes'),
  approverId?: long(name='ApproverId'),
  currentPage?: int32(name='CurrentPage'),
  jobName?: string(name='JobName'),
  order?: string(name='Order'),
  orderBy?: string(name='OrderBy'),
  pageSize?: int32(name='PageSize'),
  paramShrink?: string(name='Param'),
  projectId?: long(name='ProjectId'),
  proposerId?: long(name='ProposerId'),
  start?: int32(name='Start'),
  userId?: string(name='UserId'),
}

model ListCsccApprovalsResponseBody = {
  code?: long(name='Code'),
  data?: {
    content?: [ 
      {
        approvalId?: long(name='ApprovalId'),
        approvalState?: int32(name='ApprovalState'),
        approvalStateName?: string(name='ApprovalStateName'),
        approvalType?: int32(name='ApprovalType'),
        approvalTypeName?: string(name='ApprovalTypeName'),
        companyName?: string(name='CompanyName'),
        fullCompanyName?: string(name='FullCompanyName'),
        gmtCreate?: long(name='GmtCreate'),
        id?: long(name='Id'),
        jobId?: long(name='JobId'),
        jobName?: string(name='JobName'),
        projectId?: long(name='ProjectId'),
        projectName?: string(name='ProjectName'),
        proposerId?: long(name='ProposerId'),
        proposerName?: string(name='ProposerName'),
        serviceHost?: string(name='ServiceHost'),
        servicePort?: string(name='ServicePort'),
        snapShot?: string(name='SnapShot'),
        token?: string(name='Token'),
        transportHost?: string(name='TransportHost'),
        transportPort?: string(name='TransportPort'),
      }
    ](name='Content'),
    pageSize?: int32(name='PageSize'),
    totalCount?: int32(name='TotalCount'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListCsccApprovalsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListCsccApprovalsResponseBody(name='body'),
}

async function listCsccApprovalsWithOptions(tmpReq: ListCsccApprovalsRequest, runtime: Util.RuntimeOptions): ListCsccApprovalsResponse {
  Util.validateModel(tmpReq);
  var request = new ListCsccApprovalsShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.approvalIds)) {
    request.approvalIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.approvalIds, 'ApprovalIds', 'json');
  }
  if (!Util.isUnset(tmpReq.approvalStates)) {
    request.approvalStatesShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.approvalStates, 'ApprovalStates', 'json');
  }
  if (!Util.isUnset(tmpReq.approvalTypes)) {
    request.approvalTypesShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.approvalTypes, 'ApprovalTypes', 'json');
  }
  if (!Util.isUnset(tmpReq.param)) {
    request.paramShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.param, 'Param', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalIdsShrink)) {
    body['ApprovalIds'] = request.approvalIdsShrink;
  }
  if (!Util.isUnset(request.approvalStatesShrink)) {
    body['ApprovalStates'] = request.approvalStatesShrink;
  }
  if (!Util.isUnset(request.approvalTypesShrink)) {
    body['ApprovalTypes'] = request.approvalTypesShrink;
  }
  if (!Util.isUnset(request.approverId)) {
    body['ApproverId'] = request.approverId;
  }
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.order)) {
    body['Order'] = request.order;
  }
  if (!Util.isUnset(request.orderBy)) {
    body['OrderBy'] = request.orderBy;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.paramShrink)) {
    body['Param'] = request.paramShrink;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.proposerId)) {
    body['ProposerId'] = request.proposerId;
  }
  if (!Util.isUnset(request.start)) {
    body['Start'] = request.start;
  }
  if (!Util.isUnset(request.userId)) {
    body['UserId'] = request.userId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListCsccApprovals',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listCsccApprovals(request: ListCsccApprovalsRequest): ListCsccApprovalsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCsccApprovalsWithOptions(request, runtime);
}

model ListCsccClassificationsRequest {
  classificationName?: string(name='ClassificationName'),
}

model ListCsccClassificationsResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      classificationId?: long(name='ClassificationId'),
      classificationName?: string(name='ClassificationName'),
      description?: string(name='Description'),
      gmtModified?: string(name='GmtModified'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListCsccClassificationsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListCsccClassificationsResponseBody(name='body'),
}

async function listCsccClassificationsWithOptions(request: ListCsccClassificationsRequest, runtime: Util.RuntimeOptions): ListCsccClassificationsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.classificationName)) {
    body['ClassificationName'] = request.classificationName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListCsccClassifications',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listCsccClassifications(request: ListCsccClassificationsRequest): ListCsccClassificationsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCsccClassificationsWithOptions(request, runtime);
}

model ListCsccEventResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      eventType?: string(name='EventType'),
      userId?: string(name='UserId'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListCsccEventResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListCsccEventResponseBody(name='body'),
}

async function listCsccEventWithOptions(runtime: Util.RuntimeOptions): ListCsccEventResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'ListCsccEvent',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listCsccEvent(): ListCsccEventResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCsccEventWithOptions(runtime);
}

model ListCsccInstancesResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      end?: string(name='End'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      instanceId?: long(name='InstanceId'),
      instanceStatus?: int32(name='InstanceStatus'),
      instanceType?: int32(name='InstanceType'),
      jobId?: long(name='JobId'),
      jobModel?: int32(name='JobModel'),
      reschedule?: boolean(name='Reschedule'),
      runTime?: string(name='RunTime'),
      scheduleDs?: string(name='ScheduleDs'),
      start?: string(name='Start'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListCsccInstancesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListCsccInstancesResponseBody(name='body'),
}

async function listCsccInstancesWithOptions(runtime: Util.RuntimeOptions): ListCsccInstancesResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'ListCsccInstances',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listCsccInstances(): ListCsccInstancesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCsccInstancesWithOptions(runtime);
}

model ListCsccJobClassifyTypesRequest {
  projectId?: long(name='ProjectId'),
}

model ListCsccJobClassifyTypesResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      jobClassifyType?: int32(name='JobClassifyType'),
      jobClassifyTypeName?: string(name='JobClassifyTypeName'),
      order?: int32(name='Order'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListCsccJobClassifyTypesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListCsccJobClassifyTypesResponseBody(name='body'),
}

async function listCsccJobClassifyTypesWithOptions(request: ListCsccJobClassifyTypesRequest, runtime: Util.RuntimeOptions): ListCsccJobClassifyTypesResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListCsccJobClassifyTypes',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listCsccJobClassifyTypes(request: ListCsccJobClassifyTypesRequest): ListCsccJobClassifyTypesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCsccJobClassifyTypesWithOptions(request, runtime);
}

model ListCsccJobInstancesRequest {
  currentPage?: int32(name='CurrentPage'),
  endTime?: string(name='EndTime'),
  jobInstanceStatus?: int32(name='JobInstanceStatus'),
  jobInstanceType?: int32(name='JobInstanceType'),
  jobName?: string(name='JobName'),
  order?: string(name='Order'),
  orderBy?: string(name='OrderBy'),
  pageSize?: int32(name='PageSize'),
  param?: map[string]any(name='Param'),
  projectId?: long(name='ProjectId'),
  start?: int32(name='Start'),
  startTime?: string(name='StartTime'),
}

model ListCsccJobInstancesShrinkRequest {
  currentPage?: int32(name='CurrentPage'),
  endTime?: string(name='EndTime'),
  jobInstanceStatus?: int32(name='JobInstanceStatus'),
  jobInstanceType?: int32(name='JobInstanceType'),
  jobName?: string(name='JobName'),
  order?: string(name='Order'),
  orderBy?: string(name='OrderBy'),
  pageSize?: int32(name='PageSize'),
  paramShrink?: string(name='Param'),
  projectId?: long(name='ProjectId'),
  start?: int32(name='Start'),
  startTime?: string(name='StartTime'),
}

model ListCsccJobInstancesResponseBody = {
  code?: long(name='Code'),
  data?: {
    content?: [ 
      {
        end?: string(name='End'),
        gmtCreate?: string(name='GmtCreate'),
        gmtModified?: string(name='GmtModified'),
        id?: long(name='Id'),
        jobId?: long(name='JobId'),
        jobInstanceStatus?: int32(name='JobInstanceStatus'),
        jobInstanceType?: int32(name='JobInstanceType'),
        jobInstanceTypeName?: string(name='JobInstanceTypeName'),
        jobModel?: int32(name='JobModel'),
        jobName?: string(name='JobName'),
        jobType?: int32(name='JobType'),
        projectName?: string(name='ProjectName'),
        runTime?: string(name='RunTime'),
        scheduleDs?: string(name='ScheduleDs'),
        start?: string(name='Start'),
        statusClassify?: int32(name='StatusClassify'),
        strRunTime?: string(name='StrRunTime'),
        typeClassify?: int32(name='TypeClassify'),
      }
    ](name='Content'),
    pageSize?: int32(name='PageSize'),
    totalCount?: int32(name='TotalCount'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListCsccJobInstancesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListCsccJobInstancesResponseBody(name='body'),
}

async function listCsccJobInstancesWithOptions(tmpReq: ListCsccJobInstancesRequest, runtime: Util.RuntimeOptions): ListCsccJobInstancesResponse {
  Util.validateModel(tmpReq);
  var request = new ListCsccJobInstancesShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.param)) {
    request.paramShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.param, 'Param', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.endTime)) {
    body['EndTime'] = request.endTime;
  }
  if (!Util.isUnset(request.jobInstanceStatus)) {
    body['JobInstanceStatus'] = request.jobInstanceStatus;
  }
  if (!Util.isUnset(request.jobInstanceType)) {
    body['JobInstanceType'] = request.jobInstanceType;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.order)) {
    body['Order'] = request.order;
  }
  if (!Util.isUnset(request.orderBy)) {
    body['OrderBy'] = request.orderBy;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.paramShrink)) {
    body['Param'] = request.paramShrink;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.start)) {
    body['Start'] = request.start;
  }
  if (!Util.isUnset(request.startTime)) {
    body['StartTime'] = request.startTime;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListCsccJobInstances',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listCsccJobInstances(request: ListCsccJobInstancesRequest): ListCsccJobInstancesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCsccJobInstancesWithOptions(request, runtime);
}

model ListCsccJobModelsRequest {
  jobClassifyType?: int32(name='JobClassifyType'),
  projectId?: long(name='ProjectId'),
}

model ListCsccJobModelsResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      modeName?: string(name='ModeName'),
      modeType?: int32(name='ModeType'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListCsccJobModelsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListCsccJobModelsResponseBody(name='body'),
}

async function listCsccJobModelsWithOptions(request: ListCsccJobModelsRequest, runtime: Util.RuntimeOptions): ListCsccJobModelsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobClassifyType)) {
    body['JobClassifyType'] = request.jobClassifyType;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListCsccJobModels',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listCsccJobModels(request: ListCsccJobModelsRequest): ListCsccJobModelsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCsccJobModelsWithOptions(request, runtime);
}

model ListCsccJobScheduleTypesResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      scheduleName?: string(name='ScheduleName'),
      scheduleType?: int32(name='ScheduleType'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListCsccJobScheduleTypesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListCsccJobScheduleTypesResponseBody(name='body'),
}

async function listCsccJobScheduleTypesWithOptions(runtime: Util.RuntimeOptions): ListCsccJobScheduleTypesResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'ListCsccJobScheduleTypes',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listCsccJobScheduleTypes(): ListCsccJobScheduleTypesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCsccJobScheduleTypesWithOptions(runtime);
}

model ListCsccJobsRequest {
  currentPage?: int32(name='CurrentPage'),
  jobName?: string(name='JobName'),
  pageSize?: int32(name='PageSize'),
  projectId?: long(name='ProjectId'),
}

model ListCsccJobsResponseBody = {
  code?: long(name='Code'),
  data?: {
    content?: [ 
      {
        approvalStatus?: string(name='ApprovalStatus'),
        creatorId?: long(name='CreatorId'),
        creatorName?: string(name='CreatorName'),
        deleteStatus?: int32(name='DeleteStatus'),
        endDate?: string(name='EndDate'),
        gmtModified?: string(name='GmtModified'),
        jobId?: long(name='JobId'),
        jobName?: string(name='JobName'),
        jobType?: int32(name='JobType'),
        jobTypeName?: string(name='JobTypeName'),
        projectId?: long(name='ProjectId'),
        runStatus?: int32(name='RunStatus'),
        startDate?: string(name='StartDate'),
        updateStatus?: int32(name='UpdateStatus'),
      }
    ](name='Content'),
    pageSize?: int32(name='PageSize'),
    totalCount?: int32(name='TotalCount'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListCsccJobsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListCsccJobsResponseBody(name='body'),
}

async function listCsccJobsWithOptions(request: ListCsccJobsRequest, runtime: Util.RuntimeOptions): ListCsccJobsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListCsccJobs',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listCsccJobs(request: ListCsccJobsRequest): ListCsccJobsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCsccJobsWithOptions(request, runtime);
}

model ListCsccProjectModelsRequest {
  jobName?: string(name='JobName'),
  mode?: int32(name='Mode'),
  projectId?: long(name='ProjectId'),
}

model ListCsccProjectModelsResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      approvalId?: long(name='ApprovalId'),
      approvalStatus?: int32(name='ApprovalStatus'),
      configuration?: string(name='Configuration'),
      creatorId?: long(name='CreatorId'),
      gmtCreate?: string(name='GmtCreate'),
      jobId?: long(name='JobId'),
      jobName?: string(name='JobName'),
      jobStatus?: int32(name='JobStatus'),
      jobType?: int32(name='JobType'),
      jobTypeName?: string(name='JobTypeName'),
      mode?: int32(name='Mode'),
      modeName?: string(name='ModeName'),
      projectId?: long(name='ProjectId'),
      projectName?: string(name='ProjectName'),
      scheduleCron?: string(name='ScheduleCron'),
      scheduleType?: int32(name='ScheduleType'),
      scheduleTypeName?: string(name='ScheduleTypeName'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListCsccProjectModelsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListCsccProjectModelsResponseBody(name='body'),
}

async function listCsccProjectModelsWithOptions(request: ListCsccProjectModelsRequest, runtime: Util.RuntimeOptions): ListCsccProjectModelsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListCsccProjectModels',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listCsccProjectModels(request: ListCsccProjectModelsRequest): ListCsccProjectModelsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCsccProjectModelsWithOptions(request, runtime);
}

model ListCsccProjectNamesRequest {
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
  projectName?: string(name='ProjectName'),
}

model ListCsccProjectNamesResponseBody = {
  code?: long(name='Code'),
  data?: {
    content?: [ 
      {
        csccRegion?: string(name='CsccRegion'),
        id?: long(name='Id'),
        name?: string(name='Name'),
      }
    ](name='Content'),
    pageSize?: int32(name='PageSize'),
    totalCount?: int32(name='TotalCount'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListCsccProjectNamesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListCsccProjectNamesResponseBody(name='body'),
}

async function listCsccProjectNamesWithOptions(request: ListCsccProjectNamesRequest, runtime: Util.RuntimeOptions): ListCsccProjectNamesResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListCsccProjectNames',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listCsccProjectNames(request: ListCsccProjectNamesRequest): ListCsccProjectNamesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listCsccProjectNamesWithOptions(request, runtime);
}

model ListJobInstanceRunLogsRequest {
  jobInstanceId?: long(name='JobInstanceId'),
  verbose?: boolean(name='Verbose'),
}

model ListJobInstanceRunLogsResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      extInfo?: string(name='ExtInfo'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      hostFeatureImportance?: string(name='HostFeatureImportance'),
      id?: long(name='Id'),
      instanceId?: long(name='InstanceId'),
      instanceStatus?: int32(name='InstanceStatus'),
      jobId?: long(name='JobId'),
      jobType?: int32(name='JobType'),
      log?: string(name='Log'),
      memberId?: long(name='MemberId'),
      progress?: int32(name='Progress'),
      slaveFeatureImportance?: string(name='SlaveFeatureImportance'),
      stageDetail?: [ 
        {
          account?: string(name='Account'),
          memberId?: long(name='MemberId'),
          role?: int32(name='Role'),
          stage?: [ 
            {
              endTime?: string(name='EndTime'),
              name?: string(name='Name'),
              progress?: double(name='Progress'),
              runLog?: string(name='RunLog'),
              startTime?: string(name='StartTime'),
              status?: int32(name='Status'),
              step?: int32(name='Step'),
              type?: string(name='Type'),
              typeAlias?: string(name='TypeAlias'),
            }
          ](name='Stage'),
        }
      ](name='StageDetail'),
      stageRelation?: [ 
        {
          fromMemberId?: long(name='FromMemberId'),
          fromStep?: int32(name='FromStep'),
          toMemberId?: long(name='ToMemberId'),
          toStep?: int32(name='ToStep'),
        }
      ](name='StageRelation'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListJobInstanceRunLogsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListJobInstanceRunLogsResponseBody(name='body'),
}

async function listJobInstanceRunLogsWithOptions(request: ListJobInstanceRunLogsRequest, runtime: Util.RuntimeOptions): ListJobInstanceRunLogsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobInstanceId)) {
    body['JobInstanceId'] = request.jobInstanceId;
  }
  if (!Util.isUnset(request.verbose)) {
    body['Verbose'] = request.verbose;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListJobInstanceRunLogs',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listJobInstanceRunLogs(request: ListJobInstanceRunLogsRequest): ListJobInstanceRunLogsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listJobInstanceRunLogsWithOptions(request, runtime);
}

model ListModelingClassificationsRequest {
  classificationName?: string(name='ClassificationName'),
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
}

model ListModelingClassificationsResponseBody = {
  code?: long(name='Code'),
  data?: {
    content?: [ 
      {
        classificationId?: long(name='ClassificationId'),
        classificationName?: string(name='ClassificationName'),
        description?: string(name='Description'),
        gmtModified?: string(name='GmtModified'),
      }
    ](name='Content'),
    pageSize?: int32(name='PageSize'),
    totalCount?: int32(name='TotalCount'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListModelingClassificationsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListModelingClassificationsResponseBody(name='body'),
}

async function listModelingClassificationsWithOptions(request: ListModelingClassificationsRequest, runtime: Util.RuntimeOptions): ListModelingClassificationsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.classificationName)) {
    body['ClassificationName'] = request.classificationName;
  }
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListModelingClassifications',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listModelingClassifications(request: ListModelingClassificationsRequest): ListModelingClassificationsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listModelingClassificationsWithOptions(request, runtime);
}

model ListOnlineServiceJobClassifyTypesRequest {
  projectId?: long(name='ProjectId'),
}

model ListOnlineServiceJobClassifyTypesResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      jobClassifyType?: int32(name='JobClassifyType'),
      jobClassifyTypeName?: string(name='JobClassifyTypeName'),
      order?: int32(name='Order'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListOnlineServiceJobClassifyTypesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListOnlineServiceJobClassifyTypesResponseBody(name='body'),
}

async function listOnlineServiceJobClassifyTypesWithOptions(request: ListOnlineServiceJobClassifyTypesRequest, runtime: Util.RuntimeOptions): ListOnlineServiceJobClassifyTypesResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListOnlineServiceJobClassifyTypes',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listOnlineServiceJobClassifyTypes(request: ListOnlineServiceJobClassifyTypesRequest): ListOnlineServiceJobClassifyTypesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listOnlineServiceJobClassifyTypesWithOptions(request, runtime);
}

model ListOnlineServicesRequest {
  currentPage?: int32(name='CurrentPage'),
  onlineServiceName?: string(name='OnlineServiceName'),
  onlineServiceStatus?: int32(name='OnlineServiceStatus'),
  pageSize?: int32(name='PageSize'),
  projectId?: long(name='ProjectId'),
}

model ListOnlineServicesResponseBody = {
  code?: long(name='Code'),
  data?: {
    content?: [ 
      {
        approvalStatus?: string(name='ApprovalStatus'),
        creatorId?: long(name='CreatorId'),
        creatorName?: string(name='CreatorName'),
        deleteStatus?: int32(name='DeleteStatus'),
        endDate?: string(name='EndDate'),
        gmtModified?: string(name='GmtModified'),
        instanceId?: long(name='InstanceId'),
        jobId?: long(name='JobId'),
        jobName?: string(name='JobName'),
        jobType?: int32(name='JobType'),
        jobTypeName?: string(name='JobTypeName'),
        onlineServiceStatus?: int32(name='OnlineServiceStatus'),
        projectId?: long(name='ProjectId'),
        runStatus?: int32(name='RunStatus'),
        startDate?: string(name='StartDate'),
        updateStatus?: int32(name='UpdateStatus'),
      }
    ](name='Content'),
    pageSize?: int32(name='PageSize'),
    totalCount?: int32(name='TotalCount'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListOnlineServicesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListOnlineServicesResponseBody(name='body'),
}

async function listOnlineServicesWithOptions(request: ListOnlineServicesRequest, runtime: Util.RuntimeOptions): ListOnlineServicesResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.onlineServiceName)) {
    body['OnlineServiceName'] = request.onlineServiceName;
  }
  if (!Util.isUnset(request.onlineServiceStatus)) {
    body['OnlineServiceStatus'] = request.onlineServiceStatus;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListOnlineServices',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listOnlineServices(request: ListOnlineServicesRequest): ListOnlineServicesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listOnlineServicesWithOptions(request, runtime);
}

model ListPrivateDatasRequest {
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
  tableName?: string(name='TableName'),
}

model ListPrivateDatasResponseBody = {
  code?: long(name='Code'),
  data?: {
    content?: [ 
      {
        comment?: string(name='Comment'),
        dataSetId?: string(name='DataSetId'),
        gmtCreate?: string(name='GmtCreate'),
        gmtModified?: string(name='GmtModified'),
        id?: long(name='Id'),
        metaStatus?: int32(name='MetaStatus'),
        ownerId?: long(name='OwnerId'),
        ownerName?: string(name='OwnerName'),
        prj?: string(name='Prj'),
        srcType?: int32(name='SrcType'),
        tab?: string(name='Tab'),
        tableAlias?: string(name='TableAlias'),
        tableId?: long(name='TableId'),
      }
    ](name='Content'),
    pageSize?: int32(name='PageSize'),
    totalCount?: int32(name='TotalCount'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListPrivateDatasResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListPrivateDatasResponseBody(name='body'),
}

async function listPrivateDatasWithOptions(request: ListPrivateDatasRequest, runtime: Util.RuntimeOptions): ListPrivateDatasResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.tableName)) {
    body['TableName'] = request.tableName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListPrivateDatas',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listPrivateDatas(request: ListPrivateDatasRequest): ListPrivateDatasResponse {
  var runtime = new Util.RuntimeOptions{};
  return listPrivateDatasWithOptions(request, runtime);
}

model ListProjectMembersRequest {
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
  projectId?: long(name='ProjectId'),
}

model ListProjectMembersResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      account?: string(name='Account'),
      gmtModified?: string(name='GmtModified'),
      memberId?: long(name='MemberId'),
      memberName?: string(name='MemberName'),
      role?: int32(name='Role'),
      userId?: string(name='UserId'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListProjectMembersResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListProjectMembersResponseBody(name='body'),
}

async function listProjectMembersWithOptions(request: ListProjectMembersRequest, runtime: Util.RuntimeOptions): ListProjectMembersResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListProjectMembers',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listProjectMembers(request: ListProjectMembersRequest): ListProjectMembersResponse {
  var runtime = new Util.RuntimeOptions{};
  return listProjectMembersWithOptions(request, runtime);
}

model ListProjectMetaColumnsRequest {
  columnName?: string(name='ColumnName'),
  projectId?: long(name='ProjectId'),
  tableId?: long(name='TableId'),
}

model ListProjectMetaColumnsResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      col?: string(name='Col'),
      comment?: string(name='Comment'),
      dataType?: string(name='DataType'),
      id?: long(name='Id'),
      isPrimaryKey?: int32(name='IsPrimaryKey'),
      isPt?: int32(name='IsPt'),
      sn?: int32(name='Sn'),
      sqlType?: int32(name='SqlType'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListProjectMetaColumnsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListProjectMetaColumnsResponseBody(name='body'),
}

async function listProjectMetaColumnsWithOptions(request: ListProjectMetaColumnsRequest, runtime: Util.RuntimeOptions): ListProjectMetaColumnsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.columnName)) {
    body['ColumnName'] = request.columnName;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.tableId)) {
    body['TableId'] = request.tableId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListProjectMetaColumns',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listProjectMetaColumns(request: ListProjectMetaColumnsRequest): ListProjectMetaColumnsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listProjectMetaColumnsWithOptions(request, runtime);
}

model ListProjectMetaSourceTypesResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      id?: int32(name='Id'),
      name?: string(name='Name'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListProjectMetaSourceTypesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListProjectMetaSourceTypesResponseBody(name='body'),
}

async function listProjectMetaSourceTypesWithOptions(runtime: Util.RuntimeOptions): ListProjectMetaSourceTypesResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'ListProjectMetaSourceTypes',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listProjectMetaSourceTypes(): ListProjectMetaSourceTypesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listProjectMetaSourceTypesWithOptions(runtime);
}

model ListProjectMetasRequest {
  currentPage?: int32(name='CurrentPage'),
  dataType?: int32(name='DataType'),
  keyWord?: string(name='KeyWord'),
  ownerId?: long(name='OwnerId'),
  pageSize?: int32(name='PageSize'),
  projectId?: long(name='ProjectId'),
  tableName?: string(name='TableName'),
}

model ListProjectMetasResponseBody = {
  code?: long(name='Code'),
  data?: {
    content?: [ 
      {
        comment?: string(name='Comment'),
        dataSetId?: string(name='DataSetId'),
        gmtCreate?: string(name='GmtCreate'),
        gmtModified?: string(name='GmtModified'),
        id?: long(name='Id'),
        metaStatus?: int32(name='MetaStatus'),
        ownerId?: long(name='OwnerId'),
        ownerName?: string(name='OwnerName'),
        prj?: string(name='Prj'),
        srcType?: int32(name='SrcType'),
        tab?: string(name='Tab'),
        tableAlias?: string(name='TableAlias'),
        tableId?: long(name='TableId'),
      }
    ](name='Content'),
    pageSize?: int32(name='PageSize'),
    totalCount?: int32(name='TotalCount'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListProjectMetasResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListProjectMetasResponseBody(name='body'),
}

async function listProjectMetasWithOptions(request: ListProjectMetasRequest, runtime: Util.RuntimeOptions): ListProjectMetasResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.dataType)) {
    body['DataType'] = request.dataType;
  }
  if (!Util.isUnset(request.keyWord)) {
    body['KeyWord'] = request.keyWord;
  }
  if (!Util.isUnset(request.ownerId)) {
    body['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.tableName)) {
    body['TableName'] = request.tableName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListProjectMetas',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listProjectMetas(request: ListProjectMetasRequest): ListProjectMetasResponse {
  var runtime = new Util.RuntimeOptions{};
  return listProjectMetasWithOptions(request, runtime);
}

model ListProjectTablesRequest {
  ownerId?: long(name='OwnerId'),
  projectId?: long(name='ProjectId'),
  tableName?: string(name='TableName'),
}

model ListProjectTablesResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      comment?: string(name='Comment'),
      dataSetId?: string(name='DataSetId'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      metaStatus?: int32(name='MetaStatus'),
      ownerId?: long(name='OwnerId'),
      ownerName?: string(name='OwnerName'),
      prj?: string(name='Prj'),
      srcType?: int32(name='SrcType'),
      tab?: string(name='Tab'),
      tableAlias?: string(name='TableAlias'),
      tableId?: long(name='TableId'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListProjectTablesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListProjectTablesResponseBody(name='body'),
}

async function listProjectTablesWithOptions(request: ListProjectTablesRequest, runtime: Util.RuntimeOptions): ListProjectTablesResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.ownerId)) {
    body['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.tableName)) {
    body['TableName'] = request.tableName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListProjectTables',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listProjectTables(request: ListProjectTablesRequest): ListProjectTablesResponse {
  var runtime = new Util.RuntimeOptions{};
  return listProjectTablesWithOptions(request, runtime);
}

model ListProjectsRequest {
  currentPage?: int32(name='CurrentPage'),
  lastProjectId?: long(name='LastProjectId'),
  ownerUserId?: string(name='OwnerUserId'),
  pageSize?: int32(name='PageSize'),
  projectName?: string(name='ProjectName'),
  projectType?: int32(name='ProjectType'),
}

model ListProjectsResponseBody = {
  code?: long(name='Code'),
  data?: {
    content?: [ 
      {
        config?: string(name='Config'),
        csccProjectId?: long(name='CsccProjectId'),
        dataSourceId?: string(name='DataSourceId'),
        description?: string(name='Description'),
        gmtCreate?: string(name='GmtCreate'),
        gmtModified?: string(name='GmtModified'),
        host?: string(name='Host'),
        id?: long(name='Id'),
        members?: [ 
          {
            account?: string(name='Account'),
            gmtModified?: string(name='GmtModified'),
            memberId?: long(name='MemberId'),
            memberName?: string(name='MemberName'),
            role?: int32(name='Role'),
            userId?: string(name='UserId'),
          }
        ](name='Members'),
        name?: string(name='Name'),
        ownerId?: long(name='OwnerId'),
        ownerName?: string(name='OwnerName'),
        ownerUserId?: string(name='OwnerUserId'),
        port?: string(name='Port'),
        projectModeList?: [ int32 ](name='ProjectModeList'),
        projectStatus?: int32(name='ProjectStatus'),
        transportHost?: string(name='TransportHost'),
        transportPort?: string(name='TransportPort'),
      }
    ](name='Content'),
    pageSize?: int32(name='PageSize'),
    totalCount?: int32(name='TotalCount'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListProjectsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListProjectsResponseBody(name='body'),
}

async function listProjectsWithOptions(request: ListProjectsRequest, runtime: Util.RuntimeOptions): ListProjectsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.lastProjectId)) {
    body['LastProjectId'] = request.lastProjectId;
  }
  if (!Util.isUnset(request.ownerUserId)) {
    body['OwnerUserId'] = request.ownerUserId;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.projectType)) {
    body['ProjectType'] = request.projectType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ListProjects',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listProjects(request: ListProjectsRequest): ListProjectsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listProjectsWithOptions(request, runtime);
}

model ModifyMpcPrivateIdJobRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  participantList?: [ 
    {
      participantId?: long(name='ParticipantId'),
      participantName?: string(name='ParticipantName'),
    }
  ](name='ParticipantList'),
  planList?: [ string ](name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
}

model ModifyMpcPrivateIdJobShrinkRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  participantList?: [ 
    {
      participantId?: long(name='ParticipantId'),
      participantName?: string(name='ParticipantName'),
    }
  ](name='ParticipantList'),
  planListShrink?: string(name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeListShrink?: string(name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
}

model ModifyMpcPrivateIdJobResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ModifyMpcPrivateIdJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ModifyMpcPrivateIdJobResponseBody(name='body'),
}

async function modifyMpcPrivateIdJobWithOptions(tmpReq: ModifyMpcPrivateIdJobRequest, runtime: Util.RuntimeOptions): ModifyMpcPrivateIdJobResponse {
  Util.validateModel(tmpReq);
  var request = new ModifyMpcPrivateIdJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.planList)) {
    request.planListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.planList, 'PlanList', 'json');
  }
  if (!Util.isUnset(tmpReq.protocolTypeList)) {
    request.protocolTypeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.protocolTypeList, 'ProtocolTypeList', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.configuration)) {
    body['Configuration'] = request.configuration;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobStatus)) {
    body['JobStatus'] = request.jobStatus;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modeName)) {
    body['ModeName'] = request.modeName;
  }
  if (!Util.isUnset(request.participantList)) {
    body['ParticipantList'] = request.participantList;
  }
  if (!Util.isUnset(request.planListShrink)) {
    body['PlanList'] = request.planListShrink;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.protocolTypeListShrink)) {
    body['ProtocolTypeList'] = request.protocolTypeListShrink;
  }
  if (!Util.isUnset(request.scheduleCron)) {
    body['ScheduleCron'] = request.scheduleCron;
  }
  if (!Util.isUnset(request.scheduleType)) {
    body['ScheduleType'] = request.scheduleType;
  }
  if (!Util.isUnset(request.scheduleTypeName)) {
    body['ScheduleTypeName'] = request.scheduleTypeName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ModifyMpcPrivateIdJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function modifyMpcPrivateIdJob(request: ModifyMpcPrivateIdJobRequest): ModifyMpcPrivateIdJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyMpcPrivateIdJobWithOptions(request, runtime);
}

model ModifyMpcSqlJobRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  inputs?: [ string ](name='Inputs'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  outputs?: [ string ](name='Outputs'),
  planList?: [ string ](name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  sql?: string(name='Sql'),
}

model ModifyMpcSqlJobShrinkRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  inputsShrink?: string(name='Inputs'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  outputsShrink?: string(name='Outputs'),
  planListShrink?: string(name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeListShrink?: string(name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  sql?: string(name='Sql'),
}

model ModifyMpcSqlJobResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ModifyMpcSqlJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ModifyMpcSqlJobResponseBody(name='body'),
}

async function modifyMpcSqlJobWithOptions(tmpReq: ModifyMpcSqlJobRequest, runtime: Util.RuntimeOptions): ModifyMpcSqlJobResponse {
  Util.validateModel(tmpReq);
  var request = new ModifyMpcSqlJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.inputs)) {
    request.inputsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.inputs, 'Inputs', 'json');
  }
  if (!Util.isUnset(tmpReq.outputs)) {
    request.outputsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.outputs, 'Outputs', 'json');
  }
  if (!Util.isUnset(tmpReq.planList)) {
    request.planListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.planList, 'PlanList', 'json');
  }
  if (!Util.isUnset(tmpReq.protocolTypeList)) {
    request.protocolTypeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.protocolTypeList, 'ProtocolTypeList', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.configuration)) {
    body['Configuration'] = request.configuration;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.inputsShrink)) {
    body['Inputs'] = request.inputsShrink;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobStatus)) {
    body['JobStatus'] = request.jobStatus;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modeName)) {
    body['ModeName'] = request.modeName;
  }
  if (!Util.isUnset(request.outputsShrink)) {
    body['Outputs'] = request.outputsShrink;
  }
  if (!Util.isUnset(request.planListShrink)) {
    body['PlanList'] = request.planListShrink;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.protocolTypeListShrink)) {
    body['ProtocolTypeList'] = request.protocolTypeListShrink;
  }
  if (!Util.isUnset(request.scheduleCron)) {
    body['ScheduleCron'] = request.scheduleCron;
  }
  if (!Util.isUnset(request.scheduleType)) {
    body['ScheduleType'] = request.scheduleType;
  }
  if (!Util.isUnset(request.scheduleTypeName)) {
    body['ScheduleTypeName'] = request.scheduleTypeName;
  }
  if (!Util.isUnset(request.sql)) {
    body['Sql'] = request.sql;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ModifyMpcSqlJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function modifyMpcSqlJob(request: ModifyMpcSqlJobRequest): ModifyMpcSqlJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyMpcSqlJobWithOptions(request, runtime);
}

model ModifyPrivateIdJobRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  participantList?: [ 
    {
      participantId?: long(name='ParticipantId'),
      participantName?: string(name='ParticipantName'),
    }
  ](name='ParticipantList'),
  planList?: [ string ](name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
}

model ModifyPrivateIdJobShrinkRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  participantList?: [ 
    {
      participantId?: long(name='ParticipantId'),
      participantName?: string(name='ParticipantName'),
    }
  ](name='ParticipantList'),
  planListShrink?: string(name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeListShrink?: string(name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
}

model ModifyPrivateIdJobResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ModifyPrivateIdJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ModifyPrivateIdJobResponseBody(name='body'),
}

async function modifyPrivateIdJobWithOptions(tmpReq: ModifyPrivateIdJobRequest, runtime: Util.RuntimeOptions): ModifyPrivateIdJobResponse {
  Util.validateModel(tmpReq);
  var request = new ModifyPrivateIdJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.planList)) {
    request.planListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.planList, 'PlanList', 'json');
  }
  if (!Util.isUnset(tmpReq.protocolTypeList)) {
    request.protocolTypeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.protocolTypeList, 'ProtocolTypeList', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.configuration)) {
    body['Configuration'] = request.configuration;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobStatus)) {
    body['JobStatus'] = request.jobStatus;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modeName)) {
    body['ModeName'] = request.modeName;
  }
  if (!Util.isUnset(request.participantList)) {
    body['ParticipantList'] = request.participantList;
  }
  if (!Util.isUnset(request.planListShrink)) {
    body['PlanList'] = request.planListShrink;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.protocolTypeListShrink)) {
    body['ProtocolTypeList'] = request.protocolTypeListShrink;
  }
  if (!Util.isUnset(request.scheduleCron)) {
    body['ScheduleCron'] = request.scheduleCron;
  }
  if (!Util.isUnset(request.scheduleType)) {
    body['ScheduleType'] = request.scheduleType;
  }
  if (!Util.isUnset(request.scheduleTypeName)) {
    body['ScheduleTypeName'] = request.scheduleTypeName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ModifyPrivateIdJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function modifyPrivateIdJob(request: ModifyPrivateIdJobRequest): ModifyPrivateIdJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyPrivateIdJobWithOptions(request, runtime);
}

model ModifyProjectRequest {
  description?: string(name='Description'),
  ownerId?: long(name='OwnerId'),
  ownerName?: string(name='OwnerName'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
}

model ModifyProjectResponseBody = {
  code?: long(name='Code'),
  data?: long(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ModifyProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ModifyProjectResponseBody(name='body'),
}

async function modifyProjectWithOptions(request: ModifyProjectRequest, runtime: Util.RuntimeOptions): ModifyProjectResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.description)) {
    body['Description'] = request.description;
  }
  if (!Util.isUnset(request.ownerId)) {
    body['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.ownerName)) {
    body['OwnerName'] = request.ownerName;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ModifyProject',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function modifyProject(request: ModifyProjectRequest): ModifyProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyProjectWithOptions(request, runtime);
}

model ModifyTrustDaPsiJobRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  planList?: [ string ](name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  psiPreCacheConfig?: {
    cacheUsage?: long(name='CacheUsage'),
    isUsePsiPreCache?: boolean(name='IsUsePsiPreCache'),
    localBasePath?: string(name='LocalBasePath'),
    psiPreCacheColumn?: [ string ](name='PsiPreCacheColumn'),
    psiPreCacheDataName?: string(name='PsiPreCacheDataName'),
    psiPreCacheJobId?: long(name='PsiPreCacheJobId'),
    psiPreCacheJobName?: string(name='PsiPreCacheJobName'),
  }(name='PsiPreCacheConfig'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  sql?: string(name='Sql'),
}

model ModifyTrustDaPsiJobShrinkRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  planListShrink?: string(name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeListShrink?: string(name='ProtocolTypeList'),
  psiPreCacheConfigShrink?: string(name='PsiPreCacheConfig'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  sql?: string(name='Sql'),
}

model ModifyTrustDaPsiJobResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ModifyTrustDaPsiJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ModifyTrustDaPsiJobResponseBody(name='body'),
}

async function modifyTrustDaPsiJobWithOptions(tmpReq: ModifyTrustDaPsiJobRequest, runtime: Util.RuntimeOptions): ModifyTrustDaPsiJobResponse {
  Util.validateModel(tmpReq);
  var request = new ModifyTrustDaPsiJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.planList)) {
    request.planListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.planList, 'PlanList', 'json');
  }
  if (!Util.isUnset(tmpReq.protocolTypeList)) {
    request.protocolTypeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.protocolTypeList, 'ProtocolTypeList', 'json');
  }
  if (!Util.isUnset(tmpReq.psiPreCacheConfig)) {
    request.psiPreCacheConfigShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.psiPreCacheConfig, 'PsiPreCacheConfig', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.configuration)) {
    body['Configuration'] = request.configuration;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobStatus)) {
    body['JobStatus'] = request.jobStatus;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modeName)) {
    body['ModeName'] = request.modeName;
  }
  if (!Util.isUnset(request.planListShrink)) {
    body['PlanList'] = request.planListShrink;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.protocolTypeListShrink)) {
    body['ProtocolTypeList'] = request.protocolTypeListShrink;
  }
  if (!Util.isUnset(request.psiPreCacheConfigShrink)) {
    body['PsiPreCacheConfig'] = request.psiPreCacheConfigShrink;
  }
  if (!Util.isUnset(request.scheduleCron)) {
    body['ScheduleCron'] = request.scheduleCron;
  }
  if (!Util.isUnset(request.scheduleType)) {
    body['ScheduleType'] = request.scheduleType;
  }
  if (!Util.isUnset(request.scheduleTypeName)) {
    body['ScheduleTypeName'] = request.scheduleTypeName;
  }
  if (!Util.isUnset(request.sql)) {
    body['Sql'] = request.sql;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ModifyTrustDaPsiJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function modifyTrustDaPsiJob(request: ModifyTrustDaPsiJobRequest): ModifyTrustDaPsiJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyTrustDaPsiJobWithOptions(request, runtime);
}

model ModifyTrustDaPsiPreCacheJobRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  planList?: [ string ](name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  psiPreCacheConfig?: {
    cacheUsage?: long(name='CacheUsage'),
    isUsePsiPreCache?: boolean(name='IsUsePsiPreCache'),
    localBasePath?: string(name='LocalBasePath'),
    psiPreCacheColumn?: [ string ](name='PsiPreCacheColumn'),
    psiPreCacheDataName?: string(name='PsiPreCacheDataName'),
    psiPreCacheJobId?: long(name='PsiPreCacheJobId'),
    psiPreCacheJobName?: string(name='PsiPreCacheJobName'),
  }(name='PsiPreCacheConfig'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
}

model ModifyTrustDaPsiPreCacheJobShrinkRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  planListShrink?: string(name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeListShrink?: string(name='ProtocolTypeList'),
  psiPreCacheConfigShrink?: string(name='PsiPreCacheConfig'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
}

model ModifyTrustDaPsiPreCacheJobResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ModifyTrustDaPsiPreCacheJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ModifyTrustDaPsiPreCacheJobResponseBody(name='body'),
}

async function modifyTrustDaPsiPreCacheJobWithOptions(tmpReq: ModifyTrustDaPsiPreCacheJobRequest, runtime: Util.RuntimeOptions): ModifyTrustDaPsiPreCacheJobResponse {
  Util.validateModel(tmpReq);
  var request = new ModifyTrustDaPsiPreCacheJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.planList)) {
    request.planListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.planList, 'PlanList', 'json');
  }
  if (!Util.isUnset(tmpReq.protocolTypeList)) {
    request.protocolTypeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.protocolTypeList, 'ProtocolTypeList', 'json');
  }
  if (!Util.isUnset(tmpReq.psiPreCacheConfig)) {
    request.psiPreCacheConfigShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.psiPreCacheConfig, 'PsiPreCacheConfig', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.configuration)) {
    body['Configuration'] = request.configuration;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobStatus)) {
    body['JobStatus'] = request.jobStatus;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modeName)) {
    body['ModeName'] = request.modeName;
  }
  if (!Util.isUnset(request.planListShrink)) {
    body['PlanList'] = request.planListShrink;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.protocolTypeListShrink)) {
    body['ProtocolTypeList'] = request.protocolTypeListShrink;
  }
  if (!Util.isUnset(request.psiPreCacheConfigShrink)) {
    body['PsiPreCacheConfig'] = request.psiPreCacheConfigShrink;
  }
  if (!Util.isUnset(request.scheduleCron)) {
    body['ScheduleCron'] = request.scheduleCron;
  }
  if (!Util.isUnset(request.scheduleType)) {
    body['ScheduleType'] = request.scheduleType;
  }
  if (!Util.isUnset(request.scheduleTypeName)) {
    body['ScheduleTypeName'] = request.scheduleTypeName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ModifyTrustDaPsiPreCacheJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function modifyTrustDaPsiPreCacheJob(request: ModifyTrustDaPsiPreCacheJobRequest): ModifyTrustDaPsiPreCacheJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyTrustDaPsiPreCacheJobWithOptions(request, runtime);
}

model ModifyTrustDaSqlJobRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  inputs?: [ string ](name='Inputs'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  outputs?: [ string ](name='Outputs'),
  planList?: [ string ](name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  sql?: string(name='Sql'),
}

model ModifyTrustDaSqlJobShrinkRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  gmtCreate?: string(name='GmtCreate'),
  inputsShrink?: string(name='Inputs'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  outputsShrink?: string(name='Outputs'),
  planListShrink?: string(name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeListShrink?: string(name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  sql?: string(name='Sql'),
}

model ModifyTrustDaSqlJobResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ModifyTrustDaSqlJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ModifyTrustDaSqlJobResponseBody(name='body'),
}

async function modifyTrustDaSqlJobWithOptions(tmpReq: ModifyTrustDaSqlJobRequest, runtime: Util.RuntimeOptions): ModifyTrustDaSqlJobResponse {
  Util.validateModel(tmpReq);
  var request = new ModifyTrustDaSqlJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.inputs)) {
    request.inputsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.inputs, 'Inputs', 'json');
  }
  if (!Util.isUnset(tmpReq.outputs)) {
    request.outputsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.outputs, 'Outputs', 'json');
  }
  if (!Util.isUnset(tmpReq.planList)) {
    request.planListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.planList, 'PlanList', 'json');
  }
  if (!Util.isUnset(tmpReq.protocolTypeList)) {
    request.protocolTypeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.protocolTypeList, 'ProtocolTypeList', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.configuration)) {
    body['Configuration'] = request.configuration;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.inputsShrink)) {
    body['Inputs'] = request.inputsShrink;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobStatus)) {
    body['JobStatus'] = request.jobStatus;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modeName)) {
    body['ModeName'] = request.modeName;
  }
  if (!Util.isUnset(request.outputsShrink)) {
    body['Outputs'] = request.outputsShrink;
  }
  if (!Util.isUnset(request.planListShrink)) {
    body['PlanList'] = request.planListShrink;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.protocolTypeListShrink)) {
    body['ProtocolTypeList'] = request.protocolTypeListShrink;
  }
  if (!Util.isUnset(request.scheduleCron)) {
    body['ScheduleCron'] = request.scheduleCron;
  }
  if (!Util.isUnset(request.scheduleType)) {
    body['ScheduleType'] = request.scheduleType;
  }
  if (!Util.isUnset(request.scheduleTypeName)) {
    body['ScheduleTypeName'] = request.scheduleTypeName;
  }
  if (!Util.isUnset(request.sql)) {
    body['Sql'] = request.sql;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ModifyTrustDaSqlJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function modifyTrustDaSqlJob(request: ModifyTrustDaSqlJobRequest): ModifyTrustDaSqlJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyTrustDaSqlJobWithOptions(request, runtime);
}

model ModifyTrustMlPredictionJobRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataProcessDtoList?: [ 
    {
      binningCount?: int32(name='BinningCount'),
      binningInterval?: string(name='BinningInterval'),
      binningType?: int32(name='BinningType'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      field?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='Field'),
      processType?: int32(name='ProcessType'),
      processedValue?: string(name='ProcessedValue'),
      rawValues?: [ string ](name='RawValues'),
    }
  ](name='DataProcessDtoList'),
  dataProcessTypeOrder?: [ int32 ](name='DataProcessTypeOrder'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  featureDistribution?: int32(name='FeatureDistribution'),
  featureFormat?: int32(name='FeatureFormat'),
  gmtCreate?: string(name='GmtCreate'),
  hostFeatureNum?: int32(name='HostFeatureNum'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  outputDs?: string(name='OutputDs'),
  outputId?: long(name='OutputId'),
  outputName?: string(name='OutputName'),
  partitionType?: int32(name='PartitionType'),
  planList?: [ string ](name='PlanList'),
  predictionResultTo?: int32(name='PredictionResultTo'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  serviceApiId?: string(name='ServiceApiId'),
  slaveFeatureNum?: int32(name='SlaveFeatureNum'),
  trainingJobId?: long(name='TrainingJobId'),
  trainingJobName?: string(name='TrainingJobName'),
  trainingModelId?: long(name='TrainingModelId'),
  trainingModelName?: string(name='TrainingModelName'),
  trainingModelVersion?: string(name='TrainingModelVersion'),
  trainingModelVersionName?: string(name='TrainingModelVersionName'),
}

model ModifyTrustMlPredictionJobShrinkRequest {
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataProcessDtoList?: [ 
    {
      binningCount?: int32(name='BinningCount'),
      binningInterval?: string(name='BinningInterval'),
      binningType?: int32(name='BinningType'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      field?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='Field'),
      processType?: int32(name='ProcessType'),
      processedValue?: string(name='ProcessedValue'),
      rawValues?: [ string ](name='RawValues'),
    }
  ](name='DataProcessDtoList'),
  dataProcessTypeOrderShrink?: string(name='DataProcessTypeOrder'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  featureDistribution?: int32(name='FeatureDistribution'),
  featureFormat?: int32(name='FeatureFormat'),
  gmtCreate?: string(name='GmtCreate'),
  hostFeatureNum?: int32(name='HostFeatureNum'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  outputDs?: string(name='OutputDs'),
  outputId?: long(name='OutputId'),
  outputName?: string(name='OutputName'),
  partitionType?: int32(name='PartitionType'),
  planListShrink?: string(name='PlanList'),
  predictionResultTo?: int32(name='PredictionResultTo'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeListShrink?: string(name='ProtocolTypeList'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  serviceApiId?: string(name='ServiceApiId'),
  slaveFeatureNum?: int32(name='SlaveFeatureNum'),
  trainingJobId?: long(name='TrainingJobId'),
  trainingJobName?: string(name='TrainingJobName'),
  trainingModelId?: long(name='TrainingModelId'),
  trainingModelName?: string(name='TrainingModelName'),
  trainingModelVersion?: string(name='TrainingModelVersion'),
  trainingModelVersionName?: string(name='TrainingModelVersionName'),
}

model ModifyTrustMlPredictionJobResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ModifyTrustMlPredictionJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ModifyTrustMlPredictionJobResponseBody(name='body'),
}

async function modifyTrustMlPredictionJobWithOptions(tmpReq: ModifyTrustMlPredictionJobRequest, runtime: Util.RuntimeOptions): ModifyTrustMlPredictionJobResponse {
  Util.validateModel(tmpReq);
  var request = new ModifyTrustMlPredictionJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.dataProcessTypeOrder)) {
    request.dataProcessTypeOrderShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.dataProcessTypeOrder, 'DataProcessTypeOrder', 'json');
  }
  if (!Util.isUnset(tmpReq.planList)) {
    request.planListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.planList, 'PlanList', 'json');
  }
  if (!Util.isUnset(tmpReq.protocolTypeList)) {
    request.protocolTypeListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.protocolTypeList, 'ProtocolTypeList', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.configuration)) {
    body['Configuration'] = request.configuration;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.dataProcessDtoList)) {
    body['DataProcessDtoList'] = request.dataProcessDtoList;
  }
  if (!Util.isUnset(request.dataProcessTypeOrderShrink)) {
    body['DataProcessTypeOrder'] = request.dataProcessTypeOrderShrink;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.featureDistribution)) {
    body['FeatureDistribution'] = request.featureDistribution;
  }
  if (!Util.isUnset(request.featureFormat)) {
    body['FeatureFormat'] = request.featureFormat;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.hostFeatureNum)) {
    body['HostFeatureNum'] = request.hostFeatureNum;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobStatus)) {
    body['JobStatus'] = request.jobStatus;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modeName)) {
    body['ModeName'] = request.modeName;
  }
  if (!Util.isUnset(request.outputDs)) {
    body['OutputDs'] = request.outputDs;
  }
  if (!Util.isUnset(request.outputId)) {
    body['OutputId'] = request.outputId;
  }
  if (!Util.isUnset(request.outputName)) {
    body['OutputName'] = request.outputName;
  }
  if (!Util.isUnset(request.partitionType)) {
    body['PartitionType'] = request.partitionType;
  }
  if (!Util.isUnset(request.planListShrink)) {
    body['PlanList'] = request.planListShrink;
  }
  if (!Util.isUnset(request.predictionResultTo)) {
    body['PredictionResultTo'] = request.predictionResultTo;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.protocolTypeListShrink)) {
    body['ProtocolTypeList'] = request.protocolTypeListShrink;
  }
  if (!Util.isUnset(request.scheduleCron)) {
    body['ScheduleCron'] = request.scheduleCron;
  }
  if (!Util.isUnset(request.scheduleType)) {
    body['ScheduleType'] = request.scheduleType;
  }
  if (!Util.isUnset(request.scheduleTypeName)) {
    body['ScheduleTypeName'] = request.scheduleTypeName;
  }
  if (!Util.isUnset(request.serviceApiId)) {
    body['ServiceApiId'] = request.serviceApiId;
  }
  if (!Util.isUnset(request.slaveFeatureNum)) {
    body['SlaveFeatureNum'] = request.slaveFeatureNum;
  }
  if (!Util.isUnset(request.trainingJobId)) {
    body['TrainingJobId'] = request.trainingJobId;
  }
  if (!Util.isUnset(request.trainingJobName)) {
    body['TrainingJobName'] = request.trainingJobName;
  }
  if (!Util.isUnset(request.trainingModelId)) {
    body['TrainingModelId'] = request.trainingModelId;
  }
  if (!Util.isUnset(request.trainingModelName)) {
    body['TrainingModelName'] = request.trainingModelName;
  }
  if (!Util.isUnset(request.trainingModelVersion)) {
    body['TrainingModelVersion'] = request.trainingModelVersion;
  }
  if (!Util.isUnset(request.trainingModelVersionName)) {
    body['TrainingModelVersionName'] = request.trainingModelVersionName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ModifyTrustMlPredictionJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function modifyTrustMlPredictionJob(request: ModifyTrustMlPredictionJobRequest): ModifyTrustMlPredictionJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyTrustMlPredictionJobWithOptions(request, runtime);
}

model ModifyTrustMlTrainingJobRequest {
  algId?: long(name='AlgId'),
  algName?: string(name='AlgName'),
  algRound?: int32(name='AlgRound'),
  algTypeId?: long(name='AlgTypeId'),
  algTypeName?: string(name='AlgTypeName'),
  algVersion?: string(name='AlgVersion'),
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataProcessDtoList?: [ 
    {
      binningCount?: int32(name='BinningCount'),
      binningInterval?: string(name='BinningInterval'),
      binningType?: int32(name='BinningType'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      field?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='Field'),
      processType?: int32(name='ProcessType'),
      processedValue?: string(name='ProcessedValue'),
      rawValues?: [ string ](name='RawValues'),
    }
  ](name='DataProcessDtoList'),
  dataProcessTypeOrder?: [ int32 ](name='DataProcessTypeOrder'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  dynamicParams?: [ 
    {
      checker?: string(name='Checker'),
      displayMode?: string(name='DisplayMode'),
      inputMode?: string(name='InputMode'),
      paramName?: string(name='ParamName'),
      paramNameForDisplay?: string(name='ParamNameForDisplay'),
      paramValue?: string(name='ParamValue'),
    }
  ](name='DynamicParams'),
  featureDistribution?: int32(name='FeatureDistribution'),
  featureFormat?: int32(name='FeatureFormat'),
  gmtCreate?: string(name='GmtCreate'),
  hostFeatureNum?: int32(name='HostFeatureNum'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  partitionType?: int32(name='PartitionType'),
  planList?: [ string ](name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  randomSeed?: int32(name='RandomSeed'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  slaveFeatureNum?: int32(name='SlaveFeatureNum'),
  trainingModelId?: long(name='TrainingModelId'),
  trainingModelName?: string(name='TrainingModelName'),
  trainingModelVersion?: [ string ](name='TrainingModelVersion'),
  trainingModelVersionName?: [ string ](name='TrainingModelVersionName'),
  trainingSetProportion?: int32(name='TrainingSetProportion'),
}

model ModifyTrustMlTrainingJobShrinkRequest {
  algId?: long(name='AlgId'),
  algName?: string(name='AlgName'),
  algRound?: int32(name='AlgRound'),
  algTypeId?: long(name='AlgTypeId'),
  algTypeName?: string(name='AlgTypeName'),
  algVersion?: string(name='AlgVersion'),
  approvalId?: long(name='ApprovalId'),
  approvalStatus?: int32(name='ApprovalStatus'),
  configuration?: string(name='Configuration'),
  creatorId?: long(name='CreatorId'),
  dataProcessDtoList?: [ 
    {
      binningCount?: int32(name='BinningCount'),
      binningInterval?: string(name='BinningInterval'),
      binningType?: int32(name='BinningType'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      field?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='Field'),
      processType?: int32(name='ProcessType'),
      processedValue?: string(name='ProcessedValue'),
      rawValues?: [ string ](name='RawValues'),
    }
  ](name='DataProcessDtoList'),
  dataProcessTypeOrderShrink?: string(name='DataProcessTypeOrder'),
  dataSetDtos?: [ 
    {
      columns?: [ string ](name='Columns'),
      dataOwnerId?: long(name='DataOwnerId'),
      dataOwnerName?: string(name='DataOwnerName'),
      dataRole?: int32(name='DataRole'),
      dataSetId?: long(name='DataSetId'),
      dataSetName?: string(name='DataSetName'),
      dataSetUsage?: int32(name='DataSetUsage'),
      filterStr?: string(name='FilterStr'),
      flFeatureColumns?: [ 
        {
          columnDataType?: string(name='ColumnDataType'),
          columnDesc?: string(name='ColumnDesc'),
          columnName?: string(name='ColumnName'),
          isPartitionColumn?: boolean(name='IsPartitionColumn'),
        }
      ](name='FlFeatureColumns'),
      flLabelColumn?: string(name='FlLabelColumn'),
      inputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='InputColumns'),
      inputDs?: string(name='InputDs'),
      order?: int32(name='Order'),
      outputColumns?: [ 
        {
          dataSetRole?: int32(name='DataSetRole'),
          dataType?: string(name='DataType'),
          inputColumnDesc?: string(name='InputColumnDesc'),
          inputColumnName?: string(name='InputColumnName'),
          outputColumnDesc?: string(name='OutputColumnDesc'),
          outputColumnName?: string(name='OutputColumnName'),
        }
      ](name='OutputColumns'),
      outputDataSetId?: long(name='OutputDataSetId'),
      outputDs?: string(name='OutputDs'),
      outputName?: string(name='OutputName'),
      preSql?: string(name='PreSql'),
    }
  ](name='DataSetDtos'),
  dynamicParams?: [ 
    {
      checker?: string(name='Checker'),
      displayMode?: string(name='DisplayMode'),
      inputMode?: string(name='InputMode'),
      paramName?: string(name='ParamName'),
      paramNameForDisplay?: string(name='ParamNameForDisplay'),
      paramValue?: string(name='ParamValue'),
    }
  ](name='DynamicParams'),
  featureDistribution?: int32(name='FeatureDistribution'),
  featureFormat?: int32(name='FeatureFormat'),
  gmtCreate?: string(name='GmtCreate'),
  hostFeatureNum?: int32(name='HostFeatureNum'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobStatus?: int32(name='JobStatus'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  mode?: int32(name='Mode'),
  modeName?: string(name='ModeName'),
  partitionType?: int32(name='PartitionType'),
  planListShrink?: string(name='PlanList'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  protocolTypeList?: [ string ](name='ProtocolTypeList'),
  randomSeed?: int32(name='RandomSeed'),
  scheduleCron?: string(name='ScheduleCron'),
  scheduleType?: int32(name='ScheduleType'),
  scheduleTypeName?: string(name='ScheduleTypeName'),
  slaveFeatureNum?: int32(name='SlaveFeatureNum'),
  trainingModelId?: long(name='TrainingModelId'),
  trainingModelName?: string(name='TrainingModelName'),
  trainingModelVersionShrink?: string(name='TrainingModelVersion'),
  trainingModelVersionNameShrink?: string(name='TrainingModelVersionName'),
  trainingSetProportion?: int32(name='TrainingSetProportion'),
}

model ModifyTrustMlTrainingJobResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ModifyTrustMlTrainingJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ModifyTrustMlTrainingJobResponseBody(name='body'),
}

async function modifyTrustMlTrainingJobWithOptions(tmpReq: ModifyTrustMlTrainingJobRequest, runtime: Util.RuntimeOptions): ModifyTrustMlTrainingJobResponse {
  Util.validateModel(tmpReq);
  var request = new ModifyTrustMlTrainingJobShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.dataProcessTypeOrder)) {
    request.dataProcessTypeOrderShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.dataProcessTypeOrder, 'DataProcessTypeOrder', 'json');
  }
  if (!Util.isUnset(tmpReq.planList)) {
    request.planListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.planList, 'PlanList', 'json');
  }
  if (!Util.isUnset(tmpReq.trainingModelVersion)) {
    request.trainingModelVersionShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.trainingModelVersion, 'TrainingModelVersion', 'json');
  }
  if (!Util.isUnset(tmpReq.trainingModelVersionName)) {
    request.trainingModelVersionNameShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.trainingModelVersionName, 'TrainingModelVersionName', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.algId)) {
    body['AlgId'] = request.algId;
  }
  if (!Util.isUnset(request.algName)) {
    body['AlgName'] = request.algName;
  }
  if (!Util.isUnset(request.algRound)) {
    body['AlgRound'] = request.algRound;
  }
  if (!Util.isUnset(request.algTypeId)) {
    body['AlgTypeId'] = request.algTypeId;
  }
  if (!Util.isUnset(request.algTypeName)) {
    body['AlgTypeName'] = request.algTypeName;
  }
  if (!Util.isUnset(request.algVersion)) {
    body['AlgVersion'] = request.algVersion;
  }
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.configuration)) {
    body['Configuration'] = request.configuration;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.dataProcessDtoList)) {
    body['DataProcessDtoList'] = request.dataProcessDtoList;
  }
  if (!Util.isUnset(request.dataProcessTypeOrderShrink)) {
    body['DataProcessTypeOrder'] = request.dataProcessTypeOrderShrink;
  }
  if (!Util.isUnset(request.dataSetDtos)) {
    body['DataSetDtos'] = request.dataSetDtos;
  }
  if (!Util.isUnset(request.dynamicParams)) {
    body['DynamicParams'] = request.dynamicParams;
  }
  if (!Util.isUnset(request.featureDistribution)) {
    body['FeatureDistribution'] = request.featureDistribution;
  }
  if (!Util.isUnset(request.featureFormat)) {
    body['FeatureFormat'] = request.featureFormat;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.hostFeatureNum)) {
    body['HostFeatureNum'] = request.hostFeatureNum;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobStatus)) {
    body['JobStatus'] = request.jobStatus;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.mode)) {
    body['Mode'] = request.mode;
  }
  if (!Util.isUnset(request.modeName)) {
    body['ModeName'] = request.modeName;
  }
  if (!Util.isUnset(request.partitionType)) {
    body['PartitionType'] = request.partitionType;
  }
  if (!Util.isUnset(request.planListShrink)) {
    body['PlanList'] = request.planListShrink;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.protocolTypeList)) {
    body['ProtocolTypeList'] = request.protocolTypeList;
  }
  if (!Util.isUnset(request.randomSeed)) {
    body['RandomSeed'] = request.randomSeed;
  }
  if (!Util.isUnset(request.scheduleCron)) {
    body['ScheduleCron'] = request.scheduleCron;
  }
  if (!Util.isUnset(request.scheduleType)) {
    body['ScheduleType'] = request.scheduleType;
  }
  if (!Util.isUnset(request.scheduleTypeName)) {
    body['ScheduleTypeName'] = request.scheduleTypeName;
  }
  if (!Util.isUnset(request.slaveFeatureNum)) {
    body['SlaveFeatureNum'] = request.slaveFeatureNum;
  }
  if (!Util.isUnset(request.trainingModelId)) {
    body['TrainingModelId'] = request.trainingModelId;
  }
  if (!Util.isUnset(request.trainingModelName)) {
    body['TrainingModelName'] = request.trainingModelName;
  }
  if (!Util.isUnset(request.trainingModelVersionShrink)) {
    body['TrainingModelVersion'] = request.trainingModelVersionShrink;
  }
  if (!Util.isUnset(request.trainingModelVersionNameShrink)) {
    body['TrainingModelVersionName'] = request.trainingModelVersionNameShrink;
  }
  if (!Util.isUnset(request.trainingSetProportion)) {
    body['TrainingSetProportion'] = request.trainingSetProportion;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ModifyTrustMlTrainingJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function modifyTrustMlTrainingJob(request: ModifyTrustMlTrainingJobRequest): ModifyTrustMlTrainingJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return modifyTrustMlTrainingJobWithOptions(request, runtime);
}

model OnlineServiceApiTestRequest {
  dataId?: string(name='DataId'),
  instanceId?: long(name='InstanceId'),
  jobId?: long(name='JobId'),
  userId?: string(name='UserId'),
}

model OnlineServiceApiTestResponseBody = {
  code?: long(name='Code'),
  data?: string(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model OnlineServiceApiTestResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: OnlineServiceApiTestResponseBody(name='body'),
}

async function onlineServiceApiTestWithOptions(request: OnlineServiceApiTestRequest, runtime: Util.RuntimeOptions): OnlineServiceApiTestResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.dataId)) {
    body['DataId'] = request.dataId;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.userId)) {
    body['UserId'] = request.userId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'OnlineServiceApiTest',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function onlineServiceApiTest(request: OnlineServiceApiTestRequest): OnlineServiceApiTestResponse {
  var runtime = new Util.RuntimeOptions{};
  return onlineServiceApiTestWithOptions(request, runtime);
}

model ReportInstanceProgressRequest {
  progressInfo?: [ 
    {
      DEFAULT_LEVEL?: string(name='DEFAULT_LEVEL'),
      GSON?: {
        builderFactories?: [  map[string]any ](name='BuilderFactories'),
        builderHierarchyFactories?: [  map[string]any ](name='BuilderHierarchyFactories'),
        calls?: {
          threadLocalHashCode?: int32(name='ThreadLocalHashCode'),
        }(name='Calls'),
        complexMapKeySerialization?: boolean(name='ComplexMapKeySerialization'),
        constructorConstructor?: {
          accessor?: map[string]any(name='Accessor'),
          instanceCreators?: map[string]object(name='InstanceCreators'),
        }(name='ConstructorConstructor'),
        datePattern?: string(name='DatePattern'),
        dateStyle?: int32(name='DateStyle'),
        excluder?: {
          deserializationStrategies?: [  map[string]any ](name='DeserializationStrategies'),
          modifiers?: int32(name='Modifiers'),
          requireExpose?: boolean(name='RequireExpose'),
          serializationStrategies?: [  map[string]any ](name='SerializationStrategies'),
          serializeInnerClasses?: boolean(name='SerializeInnerClasses'),
          version?: double(name='Version'),
        }(name='Excluder'),
        factories?: [  map[string]any ](name='Factories'),
        fieldNamingStrategy?: map[string]any(name='FieldNamingStrategy'),
        generateNonExecutableJson?: boolean(name='GenerateNonExecutableJson'),
        htmlSafe?: boolean(name='HtmlSafe'),
        instanceCreators?: map[string]object(name='InstanceCreators'),
        jsonAdapterFactory?: {
          constructorConstructor?: {
            accessor?: map[string]any(name='Accessor'),
            instanceCreators?: map[string]object(name='InstanceCreators'),
          }(name='ConstructorConstructor'),
        }(name='JsonAdapterFactory'),
        lenient?: boolean(name='Lenient'),
        longSerializationPolicy?: string(name='LongSerializationPolicy'),
        prettyPrinting?: boolean(name='PrettyPrinting'),
        serializeNulls?: boolean(name='SerializeNulls'),
        serializeSpecialFloatingPointValues?: boolean(name='SerializeSpecialFloatingPointValues'),
        timeStyle?: int32(name='TimeStyle'),
        typeTokenCache?: map[string]object(name='TypeTokenCache'),
      }(name='GSON'),
      instanceId?: long(name='InstanceId'),
      instanceMsg?: string(name='InstanceMsg'),
      instanceResult?: string(name='InstanceResult'),
      instanceStatus?: int32(name='InstanceStatus'),
      jobId?: long(name='JobId'),
      jobName?: string(name='JobName'),
      PARTY_NAME?: string(name='PARTY_NAME'),
      partnerName?: string(name='PartnerName'),
      pattern?: string(name='Pattern'),
      progress?: double(name='Progress'),
      stageProgress?: string(name='StageProgress'),
      taskProgress?: string(name='TaskProgress'),
    }
  ](name='ProgressInfo'),
}

model ReportInstanceProgressShrinkRequest {
  progressInfoShrink?: string(name='ProgressInfo'),
}

model ReportInstanceProgressResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ReportInstanceProgressResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ReportInstanceProgressResponseBody(name='body'),
}

async function reportInstanceProgressWithOptions(tmpReq: ReportInstanceProgressRequest, runtime: Util.RuntimeOptions): ReportInstanceProgressResponse {
  Util.validateModel(tmpReq);
  var request = new ReportInstanceProgressShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.progressInfo)) {
    request.progressInfoShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.progressInfo, 'ProgressInfo', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.progressInfoShrink)) {
    body['ProgressInfo'] = request.progressInfoShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ReportInstanceProgress',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function reportInstanceProgress(request: ReportInstanceProgressRequest): ReportInstanceProgressResponse {
  var runtime = new Util.RuntimeOptions{};
  return reportInstanceProgressWithOptions(request, runtime);
}

model SaveProjectSettingRequest {
  projectId?: long(name='ProjectId'),
  switchs?: [ 
    {
      jobName?: string(name='JobName'),
      jobType?: int32(name='JobType'),
      modeName?: string(name='ModeName'),
      modeType?: int32(name='ModeType'),
      selected?: boolean(name='Selected'),
      visible?: boolean(name='Visible'),
    }
  ](name='Switchs'),
}

model SaveProjectSettingShrinkRequest {
  projectId?: long(name='ProjectId'),
  switchsShrink?: string(name='Switchs'),
}

model SaveProjectSettingResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SaveProjectSettingResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SaveProjectSettingResponseBody(name='body'),
}

async function saveProjectSettingWithOptions(tmpReq: SaveProjectSettingRequest, runtime: Util.RuntimeOptions): SaveProjectSettingResponse {
  Util.validateModel(tmpReq);
  var request = new SaveProjectSettingShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.switchs)) {
    request.switchsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.switchs, 'Switchs', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.switchsShrink)) {
    body['Switchs'] = request.switchsShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SaveProjectSetting',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function saveProjectSetting(request: SaveProjectSettingRequest): SaveProjectSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return saveProjectSettingWithOptions(request, runtime);
}

model SearchCsccApprovalDetailsRequest {
  approvalAction?: string(name='ApprovalAction'),
  approvalId?: long(name='ApprovalId'),
  approvalState?: int32(name='ApprovalState'),
  approvalStateName?: string(name='ApprovalStateName'),
  approvalType?: int32(name='ApprovalType'),
  approvalTypeName?: string(name='ApprovalTypeName'),
  approverId?: long(name='ApproverId'),
  approverName?: string(name='ApproverName'),
  approverUserId?: long(name='ApproverUserId'),
  companyName?: string(name='CompanyName'),
  current?: boolean(name='Current'),
  description?: string(name='Description'),
  extend?: string(name='Extend'),
  fullCompanyName?: string(name='FullCompanyName'),
  gmtCreate?: long(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  proposerId?: long(name='ProposerId'),
  proposerName?: string(name='ProposerName'),
  runEnvApprovalId?: string(name='RunEnvApprovalId'),
  runEnvJobId?: string(name='RunEnvJobId'),
  serviceHost?: string(name='ServiceHost'),
  servicePort?: string(name='ServicePort'),
  sign?: string(name='Sign'),
  snapShot?: string(name='SnapShot'),
  token?: string(name='Token'),
  transportHost?: string(name='TransportHost'),
  transportPort?: string(name='TransportPort'),
}

model SearchCsccApprovalDetailsResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      approvalAction?: string(name='ApprovalAction'),
      approvalId?: long(name='ApprovalId'),
      approvalState?: int32(name='ApprovalState'),
      approvalStateName?: string(name='ApprovalStateName'),
      approvalType?: int32(name='ApprovalType'),
      approvalTypeName?: string(name='ApprovalTypeName'),
      approverId?: long(name='ApproverId'),
      approverName?: string(name='ApproverName'),
      approverUserId?: long(name='ApproverUserId'),
      companyName?: string(name='CompanyName'),
      current?: boolean(name='Current'),
      description?: string(name='Description'),
      extend?: string(name='Extend'),
      fullCompanyName?: string(name='FullCompanyName'),
      gmtCreate?: long(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      id?: long(name='Id'),
      jobId?: long(name='JobId'),
      jobName?: string(name='JobName'),
      projectId?: long(name='ProjectId'),
      projectName?: string(name='ProjectName'),
      proposerId?: long(name='ProposerId'),
      proposerName?: string(name='ProposerName'),
      runEnvApprovalId?: string(name='RunEnvApprovalId'),
      runEnvJobId?: string(name='RunEnvJobId'),
      serviceHost?: string(name='ServiceHost'),
      servicePort?: string(name='ServicePort'),
      sign?: string(name='Sign'),
      snapShot?: string(name='SnapShot'),
      token?: string(name='Token'),
      transportHost?: string(name='TransportHost'),
      transportPort?: string(name='TransportPort'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SearchCsccApprovalDetailsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SearchCsccApprovalDetailsResponseBody(name='body'),
}

async function searchCsccApprovalDetailsWithOptions(request: SearchCsccApprovalDetailsRequest, runtime: Util.RuntimeOptions): SearchCsccApprovalDetailsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalAction)) {
    body['ApprovalAction'] = request.approvalAction;
  }
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalState)) {
    body['ApprovalState'] = request.approvalState;
  }
  if (!Util.isUnset(request.approvalStateName)) {
    body['ApprovalStateName'] = request.approvalStateName;
  }
  if (!Util.isUnset(request.approvalType)) {
    body['ApprovalType'] = request.approvalType;
  }
  if (!Util.isUnset(request.approvalTypeName)) {
    body['ApprovalTypeName'] = request.approvalTypeName;
  }
  if (!Util.isUnset(request.approverId)) {
    body['ApproverId'] = request.approverId;
  }
  if (!Util.isUnset(request.approverName)) {
    body['ApproverName'] = request.approverName;
  }
  if (!Util.isUnset(request.approverUserId)) {
    body['ApproverUserId'] = request.approverUserId;
  }
  if (!Util.isUnset(request.companyName)) {
    body['CompanyName'] = request.companyName;
  }
  if (!Util.isUnset(request.current)) {
    body['Current'] = request.current;
  }
  if (!Util.isUnset(request.description)) {
    body['Description'] = request.description;
  }
  if (!Util.isUnset(request.extend)) {
    body['Extend'] = request.extend;
  }
  if (!Util.isUnset(request.fullCompanyName)) {
    body['FullCompanyName'] = request.fullCompanyName;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.gmtModified)) {
    body['GmtModified'] = request.gmtModified;
  }
  if (!Util.isUnset(request.id)) {
    body['Id'] = request.id;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.proposerId)) {
    body['ProposerId'] = request.proposerId;
  }
  if (!Util.isUnset(request.proposerName)) {
    body['ProposerName'] = request.proposerName;
  }
  if (!Util.isUnset(request.runEnvApprovalId)) {
    body['RunEnvApprovalId'] = request.runEnvApprovalId;
  }
  if (!Util.isUnset(request.runEnvJobId)) {
    body['RunEnvJobId'] = request.runEnvJobId;
  }
  if (!Util.isUnset(request.serviceHost)) {
    body['ServiceHost'] = request.serviceHost;
  }
  if (!Util.isUnset(request.servicePort)) {
    body['ServicePort'] = request.servicePort;
  }
  if (!Util.isUnset(request.sign)) {
    body['Sign'] = request.sign;
  }
  if (!Util.isUnset(request.snapShot)) {
    body['SnapShot'] = request.snapShot;
  }
  if (!Util.isUnset(request.token)) {
    body['Token'] = request.token;
  }
  if (!Util.isUnset(request.transportHost)) {
    body['TransportHost'] = request.transportHost;
  }
  if (!Util.isUnset(request.transportPort)) {
    body['TransportPort'] = request.transportPort;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SearchCsccApprovalDetails',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function searchCsccApprovalDetails(request: SearchCsccApprovalDetailsRequest): SearchCsccApprovalDetailsResponse {
  var runtime = new Util.RuntimeOptions{};
  return searchCsccApprovalDetailsWithOptions(request, runtime);
}

model SearchCsccApprovalsRequest {
  approvalId?: long(name='ApprovalId'),
  approvalState?: int32(name='ApprovalState'),
  approvalStateName?: string(name='ApprovalStateName'),
  approvalType?: int32(name='ApprovalType'),
  approvalTypeName?: string(name='ApprovalTypeName'),
  companyName?: string(name='CompanyName'),
  fullCompanyName?: string(name='FullCompanyName'),
  gmtCreate?: long(name='GmtCreate'),
  id?: long(name='Id'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  proposerId?: long(name='ProposerId'),
  proposerName?: string(name='ProposerName'),
  serviceHost?: string(name='ServiceHost'),
  servicePort?: string(name='ServicePort'),
  snapShot?: string(name='SnapShot'),
  token?: string(name='Token'),
  transportHost?: string(name='TransportHost'),
  transportPort?: string(name='TransportPort'),
}

model SearchCsccApprovalsResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      approvalId?: long(name='ApprovalId'),
      approvalState?: int32(name='ApprovalState'),
      approvalStateName?: string(name='ApprovalStateName'),
      approvalType?: int32(name='ApprovalType'),
      approvalTypeName?: string(name='ApprovalTypeName'),
      companyName?: string(name='CompanyName'),
      fullCompanyName?: string(name='FullCompanyName'),
      gmtCreate?: long(name='GmtCreate'),
      id?: long(name='Id'),
      jobId?: long(name='JobId'),
      jobName?: string(name='JobName'),
      projectId?: long(name='ProjectId'),
      projectName?: string(name='ProjectName'),
      proposerId?: long(name='ProposerId'),
      proposerName?: string(name='ProposerName'),
      serviceHost?: string(name='ServiceHost'),
      servicePort?: string(name='ServicePort'),
      snapShot?: string(name='SnapShot'),
      token?: string(name='Token'),
      transportHost?: string(name='TransportHost'),
      transportPort?: string(name='TransportPort'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SearchCsccApprovalsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SearchCsccApprovalsResponseBody(name='body'),
}

async function searchCsccApprovalsWithOptions(request: SearchCsccApprovalsRequest, runtime: Util.RuntimeOptions): SearchCsccApprovalsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalState)) {
    body['ApprovalState'] = request.approvalState;
  }
  if (!Util.isUnset(request.approvalStateName)) {
    body['ApprovalStateName'] = request.approvalStateName;
  }
  if (!Util.isUnset(request.approvalType)) {
    body['ApprovalType'] = request.approvalType;
  }
  if (!Util.isUnset(request.approvalTypeName)) {
    body['ApprovalTypeName'] = request.approvalTypeName;
  }
  if (!Util.isUnset(request.companyName)) {
    body['CompanyName'] = request.companyName;
  }
  if (!Util.isUnset(request.fullCompanyName)) {
    body['FullCompanyName'] = request.fullCompanyName;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.id)) {
    body['Id'] = request.id;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.proposerId)) {
    body['ProposerId'] = request.proposerId;
  }
  if (!Util.isUnset(request.proposerName)) {
    body['ProposerName'] = request.proposerName;
  }
  if (!Util.isUnset(request.serviceHost)) {
    body['ServiceHost'] = request.serviceHost;
  }
  if (!Util.isUnset(request.servicePort)) {
    body['ServicePort'] = request.servicePort;
  }
  if (!Util.isUnset(request.snapShot)) {
    body['SnapShot'] = request.snapShot;
  }
  if (!Util.isUnset(request.token)) {
    body['Token'] = request.token;
  }
  if (!Util.isUnset(request.transportHost)) {
    body['TransportHost'] = request.transportHost;
  }
  if (!Util.isUnset(request.transportPort)) {
    body['TransportPort'] = request.transportPort;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SearchCsccApprovals',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function searchCsccApprovals(request: SearchCsccApprovalsRequest): SearchCsccApprovalsResponse {
  var runtime = new Util.RuntimeOptions{};
  return searchCsccApprovalsWithOptions(request, runtime);
}

model ShareBatchPrivateDataRequest {
  projectType?: int32(name='ProjectType'),
  sourceTargetList?: [ 
    {
      targetTableId?: long(name='TargetTableId'),
      targetTableName?: string(name='TargetTableName'),
    }
  ](name='SourceTargetList'),
  targetProjectId?: long(name='TargetProjectId'),
}

model ShareBatchPrivateDataResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      errMsg?: string(name='ErrMsg'),
      targetTableId?: long(name='TargetTableId'),
      targetTableName?: string(name='TargetTableName'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ShareBatchPrivateDataResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ShareBatchPrivateDataResponseBody(name='body'),
}

async function shareBatchPrivateDataWithOptions(request: ShareBatchPrivateDataRequest, runtime: Util.RuntimeOptions): ShareBatchPrivateDataResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.projectType)) {
    body['ProjectType'] = request.projectType;
  }
  if (!Util.isUnset(request.sourceTargetList)) {
    body['SourceTargetList'] = request.sourceTargetList;
  }
  if (!Util.isUnset(request.targetProjectId)) {
    body['TargetProjectId'] = request.targetProjectId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ShareBatchPrivateData',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function shareBatchPrivateData(request: ShareBatchPrivateDataRequest): ShareBatchPrivateDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return shareBatchPrivateDataWithOptions(request, runtime);
}

model SharePrivateDataRequest {
  projectType?: int32(name='ProjectType'),
  sourceTableId?: long(name='SourceTableId'),
  targetProjectId?: long(name='TargetProjectId'),
  targetTableName?: string(name='TargetTableName'),
}

model SharePrivateDataResponseBody = {
  code?: long(name='Code'),
  data?: long(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SharePrivateDataResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SharePrivateDataResponseBody(name='body'),
}

async function sharePrivateDataWithOptions(request: SharePrivateDataRequest, runtime: Util.RuntimeOptions): SharePrivateDataResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.projectType)) {
    body['ProjectType'] = request.projectType;
  }
  if (!Util.isUnset(request.sourceTableId)) {
    body['SourceTableId'] = request.sourceTableId;
  }
  if (!Util.isUnset(request.targetProjectId)) {
    body['TargetProjectId'] = request.targetProjectId;
  }
  if (!Util.isUnset(request.targetTableName)) {
    body['TargetTableName'] = request.targetTableName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SharePrivateData',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function sharePrivateData(request: SharePrivateDataRequest): SharePrivateDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return sharePrivateDataWithOptions(request, runtime);
}

model StartCsccJobRequest {
  approvalStatus?: string(name='ApprovalStatus'),
  creatorId?: long(name='CreatorId'),
  creatorName?: string(name='CreatorName'),
  deleteStatus?: int32(name='DeleteStatus'),
  endDate?: string(name='EndDate'),
  gmtModified?: string(name='GmtModified'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  jobType?: int32(name='JobType'),
  jobTypeName?: string(name='JobTypeName'),
  projectId?: long(name='ProjectId'),
  runStatus?: int32(name='RunStatus'),
  startDate?: string(name='StartDate'),
  updateStatus?: int32(name='UpdateStatus'),
}

model StartCsccJobResponseBody = {
  code?: long(name='Code'),
  data?: [ 
    {
      end?: string(name='End'),
      gmtCreate?: string(name='GmtCreate'),
      gmtModified?: string(name='GmtModified'),
      instanceId?: long(name='InstanceId'),
      instanceStatus?: int32(name='InstanceStatus'),
      instanceType?: int32(name='InstanceType'),
      jobId?: long(name='JobId'),
      jobModel?: int32(name='JobModel'),
      reschedule?: boolean(name='Reschedule'),
      runTime?: string(name='RunTime'),
      scheduleDs?: string(name='ScheduleDs'),
      start?: string(name='Start'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model StartCsccJobResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: StartCsccJobResponseBody(name='body'),
}

async function startCsccJobWithOptions(request: StartCsccJobRequest, runtime: Util.RuntimeOptions): StartCsccJobResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalStatus)) {
    body['ApprovalStatus'] = request.approvalStatus;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.creatorName)) {
    body['CreatorName'] = request.creatorName;
  }
  if (!Util.isUnset(request.deleteStatus)) {
    body['DeleteStatus'] = request.deleteStatus;
  }
  if (!Util.isUnset(request.endDate)) {
    body['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.gmtModified)) {
    body['GmtModified'] = request.gmtModified;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.jobType)) {
    body['JobType'] = request.jobType;
  }
  if (!Util.isUnset(request.jobTypeName)) {
    body['JobTypeName'] = request.jobTypeName;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.runStatus)) {
    body['RunStatus'] = request.runStatus;
  }
  if (!Util.isUnset(request.startDate)) {
    body['StartDate'] = request.startDate;
  }
  if (!Util.isUnset(request.updateStatus)) {
    body['UpdateStatus'] = request.updateStatus;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'StartCsccJob',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function startCsccJob(request: StartCsccJobRequest): StartCsccJobResponse {
  var runtime = new Util.RuntimeOptions{};
  return startCsccJobWithOptions(request, runtime);
}

model StartJobInstanceRequest {
  jobInstanceId?: long(name='JobInstanceId'),
}

model StartJobInstanceResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model StartJobInstanceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: StartJobInstanceResponseBody(name='body'),
}

async function startJobInstanceWithOptions(request: StartJobInstanceRequest, runtime: Util.RuntimeOptions): StartJobInstanceResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobInstanceId)) {
    body['JobInstanceId'] = request.jobInstanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'StartJobInstance',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function startJobInstance(request: StartJobInstanceRequest): StartJobInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return startJobInstanceWithOptions(request, runtime);
}

model StopJobInstanceRequest {
  jobInstanceId?: long(name='JobInstanceId'),
}

model StopJobInstanceResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model StopJobInstanceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: StopJobInstanceResponseBody(name='body'),
}

async function stopJobInstanceWithOptions(request: StopJobInstanceRequest, runtime: Util.RuntimeOptions): StopJobInstanceResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.jobInstanceId)) {
    body['JobInstanceId'] = request.jobInstanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'StopJobInstance',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function stopJobInstance(request: StopJobInstanceRequest): StopJobInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return stopJobInstanceWithOptions(request, runtime);
}

model SubmitCsccApprovalRequest {
  approvalAction?: string(name='ApprovalAction'),
  approvalId?: long(name='ApprovalId'),
  approvalState?: int32(name='ApprovalState'),
  approvalStateName?: string(name='ApprovalStateName'),
  approvalType?: int32(name='ApprovalType'),
  approvalTypeName?: string(name='ApprovalTypeName'),
  approverId?: long(name='ApproverId'),
  approverName?: string(name='ApproverName'),
  approverUserId?: long(name='ApproverUserId'),
  companyName?: string(name='CompanyName'),
  current?: boolean(name='Current'),
  description?: string(name='Description'),
  extend?: string(name='Extend'),
  fullCompanyName?: string(name='FullCompanyName'),
  gmtCreate?: long(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  proposerId?: long(name='ProposerId'),
  proposerName?: string(name='ProposerName'),
  runEnvApprovalId?: string(name='RunEnvApprovalId'),
  runEnvJobId?: string(name='RunEnvJobId'),
  serviceHost?: string(name='ServiceHost'),
  servicePort?: string(name='ServicePort'),
  sign?: string(name='Sign'),
  snapShot?: string(name='SnapShot'),
  token?: string(name='Token'),
  transportHost?: string(name='TransportHost'),
  transportPort?: string(name='TransportPort'),
}

model SubmitCsccApprovalResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SubmitCsccApprovalResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SubmitCsccApprovalResponseBody(name='body'),
}

async function submitCsccApprovalWithOptions(request: SubmitCsccApprovalRequest, runtime: Util.RuntimeOptions): SubmitCsccApprovalResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalAction)) {
    body['ApprovalAction'] = request.approvalAction;
  }
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalState)) {
    body['ApprovalState'] = request.approvalState;
  }
  if (!Util.isUnset(request.approvalStateName)) {
    body['ApprovalStateName'] = request.approvalStateName;
  }
  if (!Util.isUnset(request.approvalType)) {
    body['ApprovalType'] = request.approvalType;
  }
  if (!Util.isUnset(request.approvalTypeName)) {
    body['ApprovalTypeName'] = request.approvalTypeName;
  }
  if (!Util.isUnset(request.approverId)) {
    body['ApproverId'] = request.approverId;
  }
  if (!Util.isUnset(request.approverName)) {
    body['ApproverName'] = request.approverName;
  }
  if (!Util.isUnset(request.approverUserId)) {
    body['ApproverUserId'] = request.approverUserId;
  }
  if (!Util.isUnset(request.companyName)) {
    body['CompanyName'] = request.companyName;
  }
  if (!Util.isUnset(request.current)) {
    body['Current'] = request.current;
  }
  if (!Util.isUnset(request.description)) {
    body['Description'] = request.description;
  }
  if (!Util.isUnset(request.extend)) {
    body['Extend'] = request.extend;
  }
  if (!Util.isUnset(request.fullCompanyName)) {
    body['FullCompanyName'] = request.fullCompanyName;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.gmtModified)) {
    body['GmtModified'] = request.gmtModified;
  }
  if (!Util.isUnset(request.id)) {
    body['Id'] = request.id;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.proposerId)) {
    body['ProposerId'] = request.proposerId;
  }
  if (!Util.isUnset(request.proposerName)) {
    body['ProposerName'] = request.proposerName;
  }
  if (!Util.isUnset(request.runEnvApprovalId)) {
    body['RunEnvApprovalId'] = request.runEnvApprovalId;
  }
  if (!Util.isUnset(request.runEnvJobId)) {
    body['RunEnvJobId'] = request.runEnvJobId;
  }
  if (!Util.isUnset(request.serviceHost)) {
    body['ServiceHost'] = request.serviceHost;
  }
  if (!Util.isUnset(request.servicePort)) {
    body['ServicePort'] = request.servicePort;
  }
  if (!Util.isUnset(request.sign)) {
    body['Sign'] = request.sign;
  }
  if (!Util.isUnset(request.snapShot)) {
    body['SnapShot'] = request.snapShot;
  }
  if (!Util.isUnset(request.token)) {
    body['Token'] = request.token;
  }
  if (!Util.isUnset(request.transportHost)) {
    body['TransportHost'] = request.transportHost;
  }
  if (!Util.isUnset(request.transportPort)) {
    body['TransportPort'] = request.transportPort;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SubmitCsccApproval',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function submitCsccApproval(request: SubmitCsccApprovalRequest): SubmitCsccApprovalResponse {
  var runtime = new Util.RuntimeOptions{};
  return submitCsccApprovalWithOptions(request, runtime);
}

model SubmitProjectRequest {
  approvalAction?: string(name='ApprovalAction'),
  approvalId?: long(name='ApprovalId'),
  approvalState?: int32(name='ApprovalState'),
  approvalStateName?: string(name='ApprovalStateName'),
  approvalType?: int32(name='ApprovalType'),
  approvalTypeName?: string(name='ApprovalTypeName'),
  approverId?: long(name='ApproverId'),
  approverName?: string(name='ApproverName'),
  approverUserId?: long(name='ApproverUserId'),
  companyName?: string(name='CompanyName'),
  current?: boolean(name='Current'),
  description?: string(name='Description'),
  extend?: string(name='Extend'),
  fullCompanyName?: string(name='FullCompanyName'),
  gmtCreate?: long(name='GmtCreate'),
  gmtModified?: string(name='GmtModified'),
  id?: long(name='Id'),
  jobId?: long(name='JobId'),
  jobName?: string(name='JobName'),
  projectId?: long(name='ProjectId'),
  projectName?: string(name='ProjectName'),
  proposerId?: long(name='ProposerId'),
  proposerName?: string(name='ProposerName'),
  runEnvApprovalId?: string(name='RunEnvApprovalId'),
  runEnvJobId?: string(name='RunEnvJobId'),
  serviceHost?: string(name='ServiceHost'),
  servicePort?: string(name='ServicePort'),
  sign?: string(name='Sign'),
  snapShot?: string(name='SnapShot'),
  token?: string(name='Token'),
  transportHost?: string(name='TransportHost'),
  transportPort?: string(name='TransportPort'),
}

model SubmitProjectResponseBody = {
  code?: long(name='Code'),
  data?: boolean(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SubmitProjectResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SubmitProjectResponseBody(name='body'),
}

async function submitProjectWithOptions(request: SubmitProjectRequest, runtime: Util.RuntimeOptions): SubmitProjectResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.approvalAction)) {
    body['ApprovalAction'] = request.approvalAction;
  }
  if (!Util.isUnset(request.approvalId)) {
    body['ApprovalId'] = request.approvalId;
  }
  if (!Util.isUnset(request.approvalState)) {
    body['ApprovalState'] = request.approvalState;
  }
  if (!Util.isUnset(request.approvalStateName)) {
    body['ApprovalStateName'] = request.approvalStateName;
  }
  if (!Util.isUnset(request.approvalType)) {
    body['ApprovalType'] = request.approvalType;
  }
  if (!Util.isUnset(request.approvalTypeName)) {
    body['ApprovalTypeName'] = request.approvalTypeName;
  }
  if (!Util.isUnset(request.approverId)) {
    body['ApproverId'] = request.approverId;
  }
  if (!Util.isUnset(request.approverName)) {
    body['ApproverName'] = request.approverName;
  }
  if (!Util.isUnset(request.approverUserId)) {
    body['ApproverUserId'] = request.approverUserId;
  }
  if (!Util.isUnset(request.companyName)) {
    body['CompanyName'] = request.companyName;
  }
  if (!Util.isUnset(request.current)) {
    body['Current'] = request.current;
  }
  if (!Util.isUnset(request.description)) {
    body['Description'] = request.description;
  }
  if (!Util.isUnset(request.extend)) {
    body['Extend'] = request.extend;
  }
  if (!Util.isUnset(request.fullCompanyName)) {
    body['FullCompanyName'] = request.fullCompanyName;
  }
  if (!Util.isUnset(request.gmtCreate)) {
    body['GmtCreate'] = request.gmtCreate;
  }
  if (!Util.isUnset(request.gmtModified)) {
    body['GmtModified'] = request.gmtModified;
  }
  if (!Util.isUnset(request.id)) {
    body['Id'] = request.id;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.jobName)) {
    body['JobName'] = request.jobName;
  }
  if (!Util.isUnset(request.projectId)) {
    body['ProjectId'] = request.projectId;
  }
  if (!Util.isUnset(request.projectName)) {
    body['ProjectName'] = request.projectName;
  }
  if (!Util.isUnset(request.proposerId)) {
    body['ProposerId'] = request.proposerId;
  }
  if (!Util.isUnset(request.proposerName)) {
    body['ProposerName'] = request.proposerName;
  }
  if (!Util.isUnset(request.runEnvApprovalId)) {
    body['RunEnvApprovalId'] = request.runEnvApprovalId;
  }
  if (!Util.isUnset(request.runEnvJobId)) {
    body['RunEnvJobId'] = request.runEnvJobId;
  }
  if (!Util.isUnset(request.serviceHost)) {
    body['ServiceHost'] = request.serviceHost;
  }
  if (!Util.isUnset(request.servicePort)) {
    body['ServicePort'] = request.servicePort;
  }
  if (!Util.isUnset(request.sign)) {
    body['Sign'] = request.sign;
  }
  if (!Util.isUnset(request.snapShot)) {
    body['SnapShot'] = request.snapShot;
  }
  if (!Util.isUnset(request.token)) {
    body['Token'] = request.token;
  }
  if (!Util.isUnset(request.transportHost)) {
    body['TransportHost'] = request.transportHost;
  }
  if (!Util.isUnset(request.transportPort)) {
    body['TransportPort'] = request.transportPort;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SubmitProject',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function submitProject(request: SubmitProjectRequest): SubmitProjectResponse {
  var runtime = new Util.RuntimeOptions{};
  return submitProjectWithOptions(request, runtime);
}

model UploadMetaRequest {
  lsccTableDesc?: string(name='LsccTableDesc'),
  lsccTableId?: long(name='LsccTableId'),
  lsccTableName?: string(name='LsccTableName'),
  sourceTargetList?: [ 
    {
      columnDataType?: string(name='ColumnDataType'),
      columnDesc?: string(name='ColumnDesc'),
      columnName?: string(name='ColumnName'),
      columnSn?: int32(name='ColumnSn'),
      isPrimaryKey?: int32(name='IsPrimaryKey'),
      isPt?: int32(name='IsPt'),
    }
  ](name='SourceTargetList'),
}

model UploadMetaShrinkRequest {
  lsccTableDesc?: string(name='LsccTableDesc'),
  lsccTableId?: long(name='LsccTableId'),
  lsccTableName?: string(name='LsccTableName'),
  sourceTargetListShrink?: string(name='SourceTargetList'),
}

model UploadMetaResponseBody = {
  code?: long(name='Code'),
  data?: long(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UploadMetaResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UploadMetaResponseBody(name='body'),
}

async function uploadMetaWithOptions(tmpReq: UploadMetaRequest, runtime: Util.RuntimeOptions): UploadMetaResponse {
  Util.validateModel(tmpReq);
  var request = new UploadMetaShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.sourceTargetList)) {
    request.sourceTargetListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.sourceTargetList, 'SourceTargetList', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.lsccTableDesc)) {
    body['LsccTableDesc'] = request.lsccTableDesc;
  }
  if (!Util.isUnset(request.lsccTableId)) {
    body['LsccTableId'] = request.lsccTableId;
  }
  if (!Util.isUnset(request.lsccTableName)) {
    body['LsccTableName'] = request.lsccTableName;
  }
  if (!Util.isUnset(request.sourceTargetListShrink)) {
    body['SourceTargetList'] = request.sourceTargetListShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UploadMeta',
    version = '2022-08-01',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function uploadMeta(request: UploadMetaRequest): UploadMetaResponse {
  var runtime = new Util.RuntimeOptions{};
  return uploadMetaWithOptions(request, runtime);
}

